polynode 0.5.5__py3-none-any.whl

polynode/trading/onboarding.py

@@ -0,0 +1,242 @@
+"""Onboarding logic for Safe deployment, wallet type detection, approvals, and CLOB credentials."""
+
+from __future__ import annotations
+
+from typing import Any
+
+import httpx
+
+from .constants import (
+    CHAIN_ID,
+    CLOB_HOST,
+    CTF,
+    CTF_EXCHANGE,
+    NEG_RISK_ADAPTER,
+    NEG_RISK_CTF_EXCHANGE,
+    PROXY_FACTORY,
+    PROXY_INIT_CODE_HASH,
+    RELAYER_HOST,
+    SAFE_FACTORY,
+    SAFE_INIT_CODE_HASH,
+    SPENDERS,
+    USDC,
+)
+from .types import ApprovalStatus, BalanceInfo, SignatureType
+
+
+def derive_safe_address(eoa: str) -> str:
+    """Derive the CREATE2 Safe address for an EOA."""
+    try:
+        from eth_abi import encode
+        from eth_utils import keccak, to_checksum_address
+    except ImportError:
+        raise ImportError("eth-account/web3 required. Install with: pip install polynode[trading]")
+
+    eoa_lower = eoa.lower()
+    if eoa_lower.startswith("0x"):
+        eoa_lower = eoa_lower[2:]
+
+    # Salt = keccak256(abi.encode(["address"], [eoa]))
+    encoded = encode(["address"], [eoa])
+    salt = keccak(encoded)
+
+    factory_bytes = bytes.fromhex(SAFE_FACTORY[2:])
+    init_code_hash = bytes.fromhex(SAFE_INIT_CODE_HASH[2:])
+
+    addr_bytes = keccak(b"\xff" + factory_bytes + salt + init_code_hash)
+    return to_checksum_address("0x" + addr_bytes[-20:].hex())
+
+
+def derive_proxy_address(eoa: str) -> str:
+    """Derive the CREATE2 Proxy address for an EOA."""
+    try:
+        from eth_abi.packed import encode_packed
+        from eth_utils import keccak, to_checksum_address
+    except ImportError:
+        raise ImportError("eth-account/web3 required. Install with: pip install polynode[trading]")
+
+    # Salt = keccak256(encodePacked(["address"], [eoa]))
+    packed = encode_packed(["address"], [eoa])
+    salt = keccak(packed)
+
+    factory_bytes = bytes.fromhex(PROXY_FACTORY[2:])
+    init_code_hash = bytes.fromhex(PROXY_INIT_CODE_HASH[2:])
+
+    addr_bytes = keccak(b"\xff" + factory_bytes + salt + init_code_hash)
+    return to_checksum_address("0x" + addr_bytes[-20:].hex())
+
+
+async def derive_funder_address(eoa: str, sig_type: SignatureType) -> str:
+    """Derive the funder address based on signature type."""
+    if sig_type == SignatureType.POLY_GNOSIS_SAFE:
+        return derive_safe_address(eoa)
+    elif sig_type == SignatureType.POLY_PROXY:
+        return derive_proxy_address(eoa)
+    return eoa
+
+
+async def detect_wallet_type(eoa: str) -> dict:
+    """Auto-detect if a Safe or Proxy is deployed for this EOA."""
+    safe_addr = derive_safe_address(eoa)
+    proxy_addr = derive_proxy_address(eoa)
+
+    async with httpx.AsyncClient(timeout=10.0) as http:
+        # Check Safe first (most common)
+        try:
+            resp = await http.get(f"{RELAYER_HOST}/deployed?owner={eoa}&salt={eoa}")
+            if resp.is_success:
+                data = resp.json()
+                if data.get("deployed"):
+                    return {
+                        "signature_type": SignatureType.POLY_GNOSIS_SAFE,
+                        "funder_address": safe_addr,
+                    }
+        except Exception:
+            pass
+
+        # Check Proxy
+        try:
+            resp = await http.get(f"{RELAYER_HOST}/deployed?owner={eoa}&salt={eoa}&type=proxy")
+            if resp.is_success:
+                data = resp.json()
+                if data.get("deployed"):
+                    return {
+                        "signature_type": SignatureType.POLY_PROXY,
+                        "funder_address": proxy_addr,
+                    }
+        except Exception:
+            pass
+
+    # Neither deployed — default to Safe
+    return {
+        "signature_type": SignatureType.POLY_GNOSIS_SAFE,
+        "funder_address": safe_addr,
+    }
+
+
+async def is_safe_deployed(funder_address: str) -> bool:
+    """Check if a Safe/Proxy is deployed at the given address."""
+    async with httpx.AsyncClient(timeout=10.0) as http:
+        try:
+            resp = await http.get(f"{RELAYER_HOST}/deployed?address={funder_address}")
+            if resp.is_success:
+                return resp.json().get("deployed", False)
+        except Exception:
+            pass
+    return False
+
+
+async def check_approvals(funder_address: str, rpc_url: str) -> ApprovalStatus:
+    """Check token approvals for all spender contracts."""
+    try:
+        from web3 import Web3
+    except ImportError:
+        raise ImportError("web3 required. Install with: pip install polynode[trading]")
+
+    w3 = Web3(Web3.HTTPProvider(rpc_url))
+    erc20_abi = [{"inputs": [{"name": "owner", "type": "address"}, {"name": "spender", "type": "address"}], "name": "allowance", "outputs": [{"name": "", "type": "uint256"}], "stateMutability": "view", "type": "function"}]
+    erc1155_abi = [{"inputs": [{"name": "account", "type": "address"}, {"name": "operator", "type": "address"}], "name": "isApprovedForAll", "outputs": [{"name": "", "type": "bool"}], "stateMutability": "view", "type": "function"}]
+
+    usdc_contract = w3.eth.contract(address=Web3.to_checksum_address(USDC), abi=erc20_abi)
+    ctf_contract = w3.eth.contract(address=Web3.to_checksum_address(CTF), abi=erc1155_abi)
+
+    funder = Web3.to_checksum_address(funder_address)
+    max_uint = 2**256 - 1
+    threshold = max_uint // 2
+
+    usdc_status = {}
+    ctf_status = {}
+    for spender, name in [(CTF_EXCHANGE, "ctf_exchange"), (NEG_RISK_CTF_EXCHANGE, "neg_risk_ctf_exchange"), (NEG_RISK_ADAPTER, "neg_risk_adapter")]:
+        spender_addr = Web3.to_checksum_address(spender)
+        allowance = usdc_contract.functions.allowance(funder, spender_addr).call()
+        usdc_status[name] = allowance >= threshold
+        approved = ctf_contract.functions.isApprovedForAll(funder, spender_addr).call()
+        ctf_status[name] = approved
+
+    all_approved = all(usdc_status.values()) and all(ctf_status.values())
+
+    return ApprovalStatus(
+        funder_address=funder_address,
+        usdc=usdc_status,
+        ctf=ctf_status,
+        all_approved=all_approved,
+    )
+
+
+async def check_balance(funder_address: str, rpc_url: str) -> BalanceInfo:
+    """Check USDC and MATIC balance."""
+    try:
+        from web3 import Web3
+    except ImportError:
+        raise ImportError("web3 required. Install with: pip install polynode[trading]")
+
+    w3 = Web3(Web3.HTTPProvider(rpc_url))
+    erc20_abi = [{"inputs": [{"name": "account", "type": "address"}], "name": "balanceOf", "outputs": [{"name": "", "type": "uint256"}], "stateMutability": "view", "type": "function"}]
+
+    usdc_contract = w3.eth.contract(address=Web3.to_checksum_address(USDC), abi=erc20_abi)
+    funder = Web3.to_checksum_address(funder_address)
+
+    usdc_raw = usdc_contract.functions.balanceOf(funder).call()
+    matic_raw = w3.eth.get_balance(funder)
+
+    return BalanceInfo(
+        funder_address=funder_address,
+        usdc=f"{usdc_raw / 1_000_000:.2f}",
+        usdc_raw=str(usdc_raw),
+        matic=f"{matic_raw / 10**18:.4f}",
+    )
+
+
+async def create_clob_credentials(signer: Any, funder_address: str) -> dict[str, str]:
+    """Derive or create CLOB API credentials via the Polymarket CLOB API."""
+    from .types import Eip712Payload
+
+    # Build the derive-api-key signing payload
+    timestamp = str(int(__import__("time").time()))
+    nonce = 0
+
+    payload = Eip712Payload(
+        domain={
+            "name": "ClobAuthDomain",
+            "version": "1",
+            "chainId": CHAIN_ID,
+        },
+        types={
+            "ClobAuth": [
+                {"name": "address", "type": "address"},
+                {"name": "timestamp", "type": "string"},
+                {"name": "nonce", "type": "uint256"},
+            ],
+        },
+        primary_type="ClobAuth",
+        message={
+            "address": funder_address,
+            "timestamp": timestamp,
+            "nonce": nonce,
+        },
+    )
+
+    signature = await signer.sign_typed_data(payload)
+    if not signature.startswith("0x"):
+        signature = f"0x{signature}"
+
+    async with httpx.AsyncClient(timeout=10.0) as http:
+        resp = await http.post(
+            f"{CLOB_HOST}/derive-api-key",
+            json={
+                "message": payload.message,
+                "owner": funder_address,
+                "signature": signature,
+                "nonce": nonce,
+                "timestamp": timestamp,
+            },
+        )
+        if not resp.is_success:
+            raise RuntimeError(f"Failed to derive CLOB credentials: {resp.status_code} {resp.text}")
+        data = resp.json()
+
+    return {
+        "apiKey": data["apiKey"],
+        "apiSecret": data["secret"],
+        "apiPassphrase": data["passphrase"],
+    }

polynode/trading/signer.py

@@ -0,0 +1,91 @@
+"""Wallet signer abstraction — normalizes private keys and RouterSigners."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any
+
+from .types import RouterSigner, SignatureType
+
+
+@dataclass
+class NormalizedSigner:
+    address: str
+    sign_typed_data: Any  # callable
+    sign_message: Any  # callable or None
+    signature_type: SignatureType
+    funder_address: str | None = None
+
+
+async def normalize_signer(
+    signer: str | RouterSigner,
+    default_signature_type: SignatureType = SignatureType.POLY_GNOSIS_SAFE,
+) -> NormalizedSigner:
+    """Normalize a private key string or RouterSigner into a consistent interface."""
+
+    if isinstance(signer, str):
+        # Hex private key
+        try:
+            from eth_account import Account
+        except ImportError:
+            raise ImportError(
+                "eth-account is required for trading. Install with: pip install polynode[trading]"
+            )
+
+        key = signer if signer.startswith("0x") else f"0x{signer}"
+        account = Account.from_key(key)
+
+        async def _sign_typed_data(payload: Any) -> str:
+            from eth_account.messages import encode_typed_data
+            # Build full EIP-712 message dict for encode_typed_data
+            eip712_domain_type = [
+                {"name": k, "type": "string" if isinstance(v, str) else ("uint256" if isinstance(v, int) else "address")}
+                for k, v in payload.domain.items()
+            ]
+            full_message = {
+                "primaryType": payload.primary_type,
+                "domain": payload.domain,
+                "types": {**payload.types, "EIP712Domain": eip712_domain_type},
+                "message": payload.message,
+            }
+            msg = encode_typed_data(full_message=full_message)
+            signed = account.sign_message(msg)
+            return signed.signature.hex()
+
+        async def _sign_message(message: str | bytes) -> str:
+            from eth_account.messages import encode_defunct
+            if isinstance(message, bytes):
+                msg = encode_defunct(primitive=message)
+            else:
+                msg = encode_defunct(text=message)
+            signed = account.sign_message(msg)
+            return signed.signature.hex()
+
+        return NormalizedSigner(
+            address=account.address,
+            sign_typed_data=_sign_typed_data,
+            sign_message=_sign_message,
+            signature_type=default_signature_type,
+        )
+
+    if isinstance(signer, RouterSigner):
+        address = await signer.get_address()
+
+        async def _rs_sign_typed_data(payload: Any) -> str:
+            return await signer.sign_typed_data(payload)
+
+        _rs_sign_message = None
+        if hasattr(signer, "sign_message") and callable(getattr(signer, "sign_message", None)):
+            async def _rs_sign_message(message: str | bytes) -> str:
+                return await signer.sign_message(message)  # type: ignore
+
+        return NormalizedSigner(
+            address=address,
+            sign_typed_data=_rs_sign_typed_data,
+            sign_message=_rs_sign_message,
+            signature_type=default_signature_type,
+        )
+
+    raise TypeError(
+        "Unsupported signer type. Provide a hex private key string or RouterSigner."
+    )

polynode/trading/sqlite_backend.py

@@ -0,0 +1,208 @@
+"""SQLite storage backend for trading credentials, market metadata, and order history."""
+
+from __future__ import annotations
+
+import sqlite3
+import time
+from typing import Any
+
+from .constants import META_TTL_SECONDS
+from .types import HistoryParams, MarketMeta, OrderHistoryRow, SignatureType, StoredCredentials
+
+
+class TradingSqliteBackend:
+    """Local SQLite storage for trading module."""
+
+    def __init__(self, db_path: str) -> None:
+        self._db = sqlite3.connect(db_path)
+        self._db.execute("PRAGMA journal_mode=WAL")
+        self._db.execute("PRAGMA synchronous=NORMAL")
+        self._init_schema()
+
+    def _init_schema(self) -> None:
+        self._db.executescript("""
+            CREATE TABLE IF NOT EXISTS clob_credentials (
+                wallet_address TEXT PRIMARY KEY,
+                funder_address TEXT,
+                api_key TEXT NOT NULL,
+                api_secret TEXT NOT NULL,
+                api_passphrase TEXT NOT NULL,
+                signature_type INTEGER NOT NULL DEFAULT 2,
+                safe_deployed INTEGER NOT NULL DEFAULT 0,
+                approvals_set INTEGER NOT NULL DEFAULT 0,
+                created_at REAL NOT NULL,
+                updated_at REAL NOT NULL
+            );
+
+            CREATE TABLE IF NOT EXISTS market_meta (
+                token_id TEXT PRIMARY KEY,
+                tick_size TEXT NOT NULL,
+                fee_rate_bps INTEGER NOT NULL DEFAULT 0,
+                neg_risk INTEGER NOT NULL DEFAULT 0,
+                fetched_at REAL NOT NULL
+            );
+
+            CREATE TABLE IF NOT EXISTS order_history (
+                id INTEGER PRIMARY KEY AUTOINCREMENT,
+                wallet_address TEXT NOT NULL,
+                order_id TEXT,
+                token_id TEXT NOT NULL,
+                side TEXT NOT NULL,
+                price REAL NOT NULL,
+                size REAL NOT NULL,
+                order_type TEXT NOT NULL DEFAULT 'GTC',
+                status TEXT NOT NULL DEFAULT 'submitting',
+                error_msg TEXT,
+                response_json TEXT,
+                created_at REAL NOT NULL
+            );
+
+            CREATE INDEX IF NOT EXISTS idx_order_history_wallet ON order_history(wallet_address);
+            CREATE INDEX IF NOT EXISTS idx_order_history_token ON order_history(token_id);
+        """)
+
+    def get_credentials(self, wallet_address: str) -> StoredCredentials | None:
+        row = self._db.execute(
+            "SELECT * FROM clob_credentials WHERE wallet_address = ? COLLATE NOCASE",
+            (wallet_address,),
+        ).fetchone()
+        if not row:
+            return None
+        return StoredCredentials(
+            wallet_address=row[0],
+            funder_address=row[1],
+            api_key=row[2],
+            api_secret=row[3],
+            api_passphrase=row[4],
+            signature_type=SignatureType(row[5]),
+            safe_deployed=bool(row[6]),
+            approvals_set=bool(row[7]),
+            created_at=row[8],
+            updated_at=row[9],
+        )
+
+    def upsert_credentials(self, creds: StoredCredentials) -> None:
+        self._db.execute(
+            """INSERT OR REPLACE INTO clob_credentials
+               (wallet_address, funder_address, api_key, api_secret, api_passphrase,
+                signature_type, safe_deployed, approvals_set, created_at, updated_at)
+               VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)""",
+            (
+                creds.wallet_address,
+                creds.funder_address,
+                creds.api_key,
+                creds.api_secret,
+                creds.api_passphrase,
+                int(creds.signature_type),
+                int(creds.safe_deployed),
+                int(creds.approvals_set),
+                creds.created_at,
+                creds.updated_at,
+            ),
+        )
+        self._db.commit()
+
+    def delete_credentials(self, wallet_address: str) -> None:
+        self._db.execute(
+            "DELETE FROM clob_credentials WHERE wallet_address = ? COLLATE NOCASE",
+            (wallet_address,),
+        )
+        self._db.commit()
+
+    def get_all_credentials(self) -> list[StoredCredentials]:
+        rows = self._db.execute("SELECT * FROM clob_credentials").fetchall()
+        return [
+            StoredCredentials(
+                wallet_address=r[0], funder_address=r[1], api_key=r[2],
+                api_secret=r[3], api_passphrase=r[4], signature_type=SignatureType(r[5]),
+                safe_deployed=bool(r[6]), approvals_set=bool(r[7]),
+                created_at=r[8], updated_at=r[9],
+            )
+            for r in rows
+        ]
+
+    def get_market_meta(self, token_id: str) -> MarketMeta | None:
+        row = self._db.execute(
+            "SELECT * FROM market_meta WHERE token_id = ?", (token_id,)
+        ).fetchone()
+        if not row:
+            return None
+        meta = MarketMeta(
+            token_id=row[0], tick_size=row[1], fee_rate_bps=row[2],
+            neg_risk=bool(row[3]), fetched_at=row[4],
+        )
+        if time.time() - meta.fetched_at > META_TTL_SECONDS:
+            return None
+        return meta
+
+    def upsert_market_meta(self, meta: MarketMeta) -> None:
+        self._db.execute(
+            """INSERT OR REPLACE INTO market_meta
+               (token_id, tick_size, fee_rate_bps, neg_risk, fetched_at)
+               VALUES (?, ?, ?, ?, ?)""",
+            (meta.token_id, meta.tick_size, meta.fee_rate_bps, int(meta.neg_risk), meta.fetched_at),
+        )
+        self._db.commit()
+
+    def insert_order(self, order: dict[str, Any]) -> int:
+        cur = self._db.execute(
+            """INSERT INTO order_history
+               (wallet_address, order_id, token_id, side, price, size, order_type,
+                status, error_msg, response_json, created_at)
+               VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)""",
+            (
+                order["wallet_address"], order.get("order_id"), order["token_id"],
+                order["side"], order["price"], order["size"], order.get("order_type", "GTC"),
+                order.get("status", "submitting"), order.get("error_msg"),
+                order.get("response_json"), order.get("created_at", time.time()),
+            ),
+        )
+        self._db.commit()
+        return cur.lastrowid  # type: ignore
+
+    def update_order_status(
+        self, row_id: int, status: str, order_id: str | None = None,
+        error_msg: str | None = None, response_json: str | None = None,
+    ) -> None:
+        self._db.execute(
+            """UPDATE order_history
+               SET status = ?, order_id = COALESCE(?, order_id),
+                   error_msg = COALESCE(?, error_msg), response_json = COALESCE(?, response_json)
+               WHERE id = ?""",
+            (status, order_id, error_msg, response_json, row_id),
+        )
+        self._db.commit()
+
+    def get_order_history(self, wallet_address: str, params: HistoryParams | None = None) -> list[OrderHistoryRow]:
+        sql = "SELECT * FROM order_history WHERE wallet_address = ? COLLATE NOCASE"
+        args: list[Any] = [wallet_address]
+
+        if params:
+            if params.token_id:
+                sql += " AND token_id = ?"
+                args.append(params.token_id)
+            if params.side:
+                sql += " AND side = ?"
+                args.append(params.side)
+
+        sql += " ORDER BY created_at DESC"
+
+        if params and params.limit:
+            sql += " LIMIT ?"
+            args.append(params.limit)
+        if params and params.offset:
+            sql += " OFFSET ?"
+            args.append(params.offset)
+
+        rows = self._db.execute(sql, args).fetchall()
+        return [
+            OrderHistoryRow(
+                id=r[0], wallet_address=r[1], order_id=r[2], token_id=r[3],
+                side=r[4], price=r[5], size=r[6], order_type=r[7],
+                status=r[8], error_msg=r[9], response_json=r[10], created_at=r[11],
+            )
+            for r in rows
+        ]
+
+    def close(self) -> None:
+        self._db.close()