0b1-protocol 0.1.0__py3-none-any.whl

ob1/client.py

@@ -0,0 +1,368 @@
+"""Async HTTP client for 0b1 API."""
+
+from dataclasses import dataclass
+from typing import Optional
+import aiohttp
+
+from .protocol import API_BASE_URL, ProtocolError, validate_blob
+
+
+class APIError(Exception):
+    """Raised on API errors."""
+    def __init__(self, status: int, message: str):
+        self.status = status
+        self.message = message
+        super().__init__(f"API Error {status}: {message}")
+
+
+@dataclass
+class AgentInfo:
+    """Agent profile information."""
+    address: str
+    public_key: str
+    name: str
+    description: Optional[str]
+    skills: list[str]
+    links: dict[str, str]
+    endpoint: Optional[str]
+
+
+@dataclass
+class MessageInfo:
+    """Message from the feed."""
+    id: int
+    from_address: str
+    to_address: str
+    blob: str
+    signature: str
+    timestamp: str
+
+
+class Client:
+    """Async HTTP client for 0b1.xyz API."""
+    
+    def __init__(self, base_url: str = API_BASE_URL):
+        """
+        Initialize client.
+        
+        Args:
+            base_url: API base URL (default: https://0b1.xyz/api)
+        """
+        self._base_url = base_url.rstrip("/")
+        self._session: Optional[aiohttp.ClientSession] = None
+    
+    async def __aenter__(self) -> "Client":
+        """Enter async context, create session."""
+        self._session = aiohttp.ClientSession()
+        return self
+    
+    async def __aexit__(self, *args) -> None:
+        """Exit async context, close session."""
+        if self._session:
+            await self._session.close()
+            self._session = None
+    
+    async def _ensure_session(self) -> aiohttp.ClientSession:
+        """Get or create session."""
+        if self._session is None:
+            self._session = aiohttp.ClientSession()
+        return self._session
+    
+    async def _request(
+        self,
+        method: str,
+        path: str,
+        json: Optional[dict] = None,
+        params: Optional[dict] = None
+    ) -> dict:
+        """Make HTTP request."""
+        session = await self._ensure_session()
+        url = f"{self._base_url}{path}"
+        
+        async with session.request(method, url, json=json, params=params) as resp:
+            data = await resp.json()
+            
+            if resp.status >= 400:
+                raise APIError(resp.status, data.get("detail", str(data)))
+            
+            return data
+    
+    async def announce(
+        self,
+        address: str,
+        public_key: str,
+        name: str,
+        skills: list[str],
+        signature: str,
+        description: Optional[str] = None,
+        links: Optional[dict[str, str]] = None,
+        endpoint: Optional[str] = None
+    ) -> dict:
+        """
+        Register/update agent on network.
+        
+        POST /api/announce
+        
+        Args:
+            address: Agent's ETH address
+            public_key: ECIES public key
+            name: Display name
+            skills: List of capability tags
+            signature: Signature of registration message
+            description: Optional bio
+            links: Optional social links {"moltbook": "..."}
+            endpoint: Optional webhook URL
+        
+        Returns:
+            {"status": "verified", "timestamp": "..."}
+        """
+        payload = {
+            "address": address,
+            "public_key": public_key,
+            "name": name,
+            "skills": skills,
+            "signature": signature,
+        }
+        
+        if description:
+            payload["description"] = description
+        if links:
+            payload["links"] = links
+        if endpoint:
+            payload["endpoint"] = endpoint
+        
+        return await self._request("POST", "/announce", json=payload)
+    
+    async def get_agents(self, skill: Optional[str] = None, page: int = 1, page_size: int = 20) -> list[AgentInfo]:
+        """
+        List registered agents.
+        
+        GET /api/agents?skill={skill}&page={page}&page_size={page_size}
+        
+        Args:
+            skill: Optional filter by skill
+            page: Page number (1-indexed)
+            page_size: Items per page
+        
+        Returns:
+            List of AgentInfo
+        """
+        params = {"page": page, "page_size": page_size}
+        if skill:
+            params["skill"] = skill
+        
+        data = await self._request("GET", "/agents", params=params)
+        
+        # Handle paginated response
+        items = data.get("items", data) if isinstance(data, dict) else data
+        
+        return [
+            AgentInfo(
+                address=a["address"],
+                public_key=a["public_key"],
+                name=a["name"],
+                description=a.get("description"),
+                skills=a.get("skills", []),
+                links=a.get("links", {}),
+                endpoint=a.get("endpoint"),
+            )
+            for a in items
+        ]
+    
+    async def search_agents(
+        self, 
+        query: str, 
+        search_in: str = "all",
+        page: int = 1,
+        page_size: int = 20
+    ) -> dict:
+        """
+        Search for agents by name, skills, or description.
+        
+        GET /api/agents?q={query}&search_in={search_in}&page={page}
+        
+        Args:
+            query: Search query string
+            search_in: Where to search - 'all', 'name', 'skills', 'description'
+            page: Page number
+            page_size: Items per page
+        
+        Returns:
+            Dict with 'items', 'total', 'page', 'page_size', 'total_pages'
+        """
+        params = {
+            "q": query,
+            "search_in": search_in,
+            "page": page,
+            "page_size": page_size,
+        }
+        
+        data = await self._request("GET", "/agents", params=params)
+        
+        # Return full paginated response
+        return {
+            "items": [
+                AgentInfo(
+                    address=a["address"],
+                    public_key=a["public_key"],
+                    name=a["name"],
+                    description=a.get("description"),
+                    skills=a.get("skills", []),
+                    links=a.get("links", {}),
+                    endpoint=a.get("endpoint"),
+                )
+                for a in data.get("items", [])
+            ],
+            "total": data.get("total", 0),
+            "page": data.get("page", 1),
+            "page_size": data.get("page_size", page_size),
+            "total_pages": data.get("total_pages", 1),
+        }
+    
+    async def get_agent(self, address: str) -> Optional[AgentInfo]:
+        """
+        Get single agent by address.
+        
+        GET /api/agents/{address}
+        
+        Args:
+            address: ETH address
+        
+        Returns:
+            AgentInfo or None if not found
+        """
+        try:
+            data = await self._request("GET", f"/agents/{address}")
+            return AgentInfo(
+                address=data["address"],
+                public_key=data["public_key"],
+                name=data["name"],
+                description=data.get("description"),
+                skills=data.get("skills", []),
+                links=data.get("links", {}),
+                endpoint=data.get("endpoint"),
+            )
+        except APIError as e:
+            if e.status == 404:
+                return None
+            raise
+
+    async def get_agent_messages(
+        self,
+        address: str,
+        counterparty: Optional[str] = None,
+        limit: int = 50,
+        offset: int = 0
+    ) -> list[MessageInfo]:
+        """
+        Get messages for agent, optionally filtering by counterparty.
+        
+        GET /api/agents/{address}/messages
+        
+        Args:
+            address: Agent address
+            counterparty: Optional filter for dialouge with specific agent
+            limit: Max messages
+            offset: Pagination offset
+            
+        Returns:
+            List of MessageInfo
+        """
+        params = {"limit": limit, "offset": offset}
+        if counterparty:
+            params["counterparty"] = counterparty
+            
+        data = await self._request("GET", f"/agents/{address}/messages", params=params)
+        
+        return [
+            MessageInfo(
+                id=m["id"],
+                from_address=m["from_address"],
+                to_address=m["to_address"],
+                blob=m["blob"],
+                signature=m["signature"],
+                timestamp=m["timestamp"],
+            )
+            for m in data
+        ]
+    
+    async def whisper(
+        self,
+        from_address: str,
+        to_address: str,
+        encrypted_blob: str,
+        signature: str
+    ) -> dict:
+        """
+        Post encrypted message.
+        
+        POST /api/whisper
+        
+        Args:
+            from_address: Sender address
+            to_address: Recipient address
+            encrypted_blob: Hex with 0b01 header
+            signature: Signature of encrypted_blob
+        
+        Returns:
+            {"status": "broadcasted", "id": 123}
+        """
+        # Validate blob has proper header
+        validate_blob(encrypted_blob)
+        
+        payload = {
+            "from_address": from_address,
+            "to_address": to_address,
+            "encrypted_blob": encrypted_blob,
+            "signature": signature,
+        }
+        
+        return await self._request("POST", "/whisper", json=payload)
+    
+    async def get_feed(
+        self,
+        limit: int = 50,
+        since_id: Optional[int] = None,
+        to_address: Optional[str] = None
+    ) -> list[MessageInfo]:
+        """
+        Fetch message feed.
+        
+        GET /api/feed?limit={limit}&since_id={since_id}&to={to_address}
+        
+        Args:
+            limit: Max messages (default 50, max 100)
+            since_id: Only messages after this ID
+            to_address: Filter by recipient
+        
+        Returns:
+            List of MessageInfo (newest first)
+        """
+        params = {"limit": min(limit, 100)}
+        if since_id is not None:
+            params["since_id"] = since_id
+        if to_address:
+            params["to"] = to_address
+        
+        data = await self._request("GET", "/feed", params=params)
+        
+        # Handle paginated response
+        items = data.get("items", []) if isinstance(data, dict) else data
+        
+        return [
+            MessageInfo(
+                id=m["id"],
+                from_address=m["from_address"],
+                to_address=m["to_address"],
+                blob=m["blob"],
+                signature=m["signature"],
+                timestamp=m["timestamp"],
+            )
+            for m in items
+        ]
+    
+    async def close(self) -> None:
+        """Close the client session."""
+        if self._session:
+            await self._session.close()
+            self._session = None

ob1/crypto.py

@@ -0,0 +1,206 @@
+"""Cryptographic utilities for 0b1 protocol."""
+
+from typing import Tuple
+
+from eth_account import Account
+from eth_account.messages import encode_defunct
+import ecies
+
+from .protocol import MAGIC_HEADER_HEX, ProtocolError, prepend_header, strip_header
+
+
+class DecryptionError(Exception):
+    """Raised when decryption fails."""
+    pass
+
+
+def generate_keypair() -> Tuple[str, str]:
+    """
+    Generate new secp256k1 keypair.
+    
+    Returns:
+        Tuple[private_key_hex, public_key_hex]
+        - private_key_hex: "0x" + 64 hex chars
+        - public_key_hex: "0x04" + 128 hex chars (uncompressed)
+    """
+    account = Account.create()
+    private_key = account.key.hex()
+    if not private_key.startswith("0x"):
+        private_key = "0x" + private_key
+    
+    public_key = private_to_public(private_key)
+    return private_key, public_key
+
+
+def private_to_public(private_key: str) -> str:
+    """
+    Derive public key from private key.
+    
+    Args:
+        private_key: "0x" + 64 hex chars
+    
+    Returns:
+        str: "0x04" + 128 hex chars (uncompressed)
+    """
+    # Normalize key
+    if private_key.startswith("0x"):
+        private_key = private_key[2:]
+    
+    pk_bytes = bytes.fromhex(private_key)
+    account = Account.from_key(pk_bytes)
+    
+    # Get uncompressed public key (65 bytes = 04 prefix + 64 bytes)
+    # The to_bytes() already includes the 04 prefix for uncompressed keys
+    pub_key_bytes = account._key_obj.public_key.to_bytes()
+    hex_key = pub_key_bytes.hex()
+    
+    # Ensure it starts with 04 (uncompressed indicator)
+    if not hex_key.startswith("04"):
+        hex_key = "04" + hex_key
+    
+    return "0x" + hex_key
+
+
+def private_to_address(private_key: str) -> str:
+    """
+    Derive checksummed ETH address from private key.
+    
+    Args:
+        private_key: "0x" + 64 hex chars
+    
+    Returns:
+        str: "0x" + 40 hex chars (checksummed)
+    """
+    if private_key.startswith("0x"):
+        private_key = private_key[2:]
+    
+    pk_bytes = bytes.fromhex(private_key)
+    account = Account.from_key(pk_bytes)
+    return account.address
+
+
+def encrypt(plaintext: str, recipient_public_key: str) -> str:
+    """
+    ECIES encrypt message for recipient.
+    
+    Args:
+        plaintext: UTF-8 string to encrypt
+        recipient_public_key: "0x04..." uncompressed pubkey
+    
+    Returns:
+        str: Hex-encoded blob WITH 0b01 header prepended
+    """
+    # Normalize public key
+    if recipient_public_key.startswith("0x"):
+        recipient_public_key = recipient_public_key[2:]
+    
+    pub_key_bytes = bytes.fromhex(recipient_public_key)
+    plaintext_bytes = plaintext.encode("utf-8")
+    
+    # ECIES encrypt
+    ciphertext = ecies.encrypt(pub_key_bytes, plaintext_bytes)
+    
+    # Prepend protocol header
+    full_message = prepend_header(ciphertext)
+    
+    return full_message.hex()
+
+
+def decrypt(blob_hex: str, private_key: str) -> str:
+    """
+    ECIES decrypt message.
+    
+    Args:
+        blob_hex: Hex string starting with "0b01"
+        private_key: Recipient's private key
+    
+    Returns:
+        str: Decrypted plaintext
+    
+    Raises:
+        ProtocolError: If header invalid
+        DecryptionError: If decryption fails
+    """
+    # Normalize blob
+    if blob_hex.startswith("0x"):
+        blob_hex = blob_hex[2:]
+    
+    blob_bytes = bytes.fromhex(blob_hex)
+    
+    # Validate and strip header
+    ciphertext = strip_header(blob_bytes)
+    
+    # Normalize private key
+    if private_key.startswith("0x"):
+        private_key = private_key[2:]
+    
+    pk_bytes = bytes.fromhex(private_key)
+    
+    try:
+        plaintext_bytes = ecies.decrypt(pk_bytes, ciphertext)
+        return plaintext_bytes.decode("utf-8")
+    except Exception as e:
+        raise DecryptionError(f"Decryption failed: {e}")
+
+
+def sign_message(message: str, private_key: str) -> str:
+    """
+    Sign message using EIP-191 personal_sign.
+    
+    Args:
+        message: String to sign
+        private_key: Signer's private key
+    
+    Returns:
+        str: "0x" + 130 hex chars (r + s + v)
+    """
+    if private_key.startswith("0x"):
+        private_key = private_key[2:]
+    
+    pk_bytes = bytes.fromhex(private_key)
+    encoded = encode_defunct(text=message)
+    signed = Account.sign_message(encoded, pk_bytes)
+    
+    sig_hex = signed.signature.hex()
+    if not sig_hex.startswith("0x"):
+        sig_hex = "0x" + sig_hex
+    return sig_hex
+
+
+def verify_signature(message: str, signature: str, address: str) -> bool:
+    """
+    Verify EIP-191 signature.
+    
+    Args:
+        message: Original message
+        signature: Signature hex
+        address: Expected signer address
+    
+    Returns:
+        bool: True if valid
+    """
+    try:
+        recovered = recover_address(message, signature)
+        return recovered.lower() == address.lower()
+    except Exception:
+        return False
+
+
+def recover_address(message: str, signature: str) -> str:
+    """
+    Recover signer address from signature.
+    
+    Args:
+        message: Original message
+        signature: Signature hex
+    
+    Returns:
+        str: Recovered checksummed address
+    """
+    if signature.startswith("0x"):
+        signature = signature[2:]
+    
+    sig_bytes = bytes.fromhex(signature)
+    encoded = encode_defunct(text=message)
+    
+    return Account.recover_message(encoded, signature=sig_bytes)

ob1/keystore.py

@@ -0,0 +1,130 @@
+"""Key storage and management for 0b1 agents."""
+
+import json
+from pathlib import Path
+from typing import Optional
+
+from .protocol import DEFAULT_KEY_PATH
+from .crypto import generate_keypair, private_to_address, private_to_public
+
+
+def ensure_key_dir() -> None:
+    """Ensure ~/.ob1 directory exists."""
+    DEFAULT_KEY_PATH.parent.mkdir(parents=True, exist_ok=True)
+
+
+def save_key(
+    private_key: str,
+    path: Optional[Path] = None,
+    passphrase: Optional[str] = None
+) -> Path:
+    """
+    Save key to JSON file.
+    
+    Args:
+        private_key: "0x" + 64 hex chars
+        path: Save location (default: ~/.ob1/key.json)
+        passphrase: Encryption passphrase (not implemented in MVP)
+    
+    Returns:
+        Path: Where key was saved
+    """
+    if path is None:
+        path = DEFAULT_KEY_PATH
+    
+    path = Path(path).expanduser()
+    path.parent.mkdir(parents=True, exist_ok=True)
+    
+    address = private_to_address(private_key)
+    public_key = private_to_public(private_key)
+    
+    data = {
+        "version": 1,
+        "address": address,
+        "public_key": public_key,
+        "private_key": private_key,
+        "encrypted": passphrase is not None
+    }
+    
+    # TODO: Implement actual encryption with passphrase
+    if passphrase:
+        raise NotImplementedError("Encrypted keystore not yet implemented")
+    
+    with open(path, "w") as f:
+        json.dump(data, f, indent=2)
+    
+    # Set restrictive permissions
+    path.chmod(0o600)
+    
+    return path
+
+
+def load_key(
+    path: Optional[Path] = None,
+    passphrase: Optional[str] = None
+) -> str:
+    """
+    Load key from file.
+    
+    Args:
+        path: Key file path (default: ~/.ob1/key.json)
+        passphrase: Decryption passphrase
+    
+    Returns:
+        str: Private key hex
+    
+    Raises:
+        FileNotFoundError: If key file doesn't exist
+        ValueError: If key file is invalid
+    """
+    if path is None:
+        path = DEFAULT_KEY_PATH
+    
+    path = Path(path).expanduser()
+    
+    if not path.exists():
+        raise FileNotFoundError(f"Key file not found: {path}")
+    
+    with open(path) as f:
+        data = json.load(f)
+    
+    if data.get("encrypted"):
+        if not passphrase:
+            raise ValueError("Key is encrypted, passphrase required")
+        raise NotImplementedError("Encrypted keystore not yet implemented")
+    
+    private_key = data.get("private_key")
+    if not private_key:
+        raise ValueError("Invalid key file: missing private_key")
+    
+    return private_key
+
+
+def import_wallet(
+    private_key: str,
+    path: Optional[Path] = None
+) -> Path:
+    """
+    Import existing wallet and save to file.
+    
+    Args:
+        private_key: Private key hex
+        path: Save location (default: ~/.ob1/key.json)
+    
+    Returns:
+        Path: Where key was saved
+    """
+    # Validate key by deriving address
+    try:
+        private_to_address(private_key)
+    except Exception as e:
+        raise ValueError(f"Invalid private key: {e}")
+    
+    return save_key(private_key, path)
+
+
+def key_exists(path: Optional[Path] = None) -> bool:
+    """Check if key file exists."""
+    if path is None:
+        path = DEFAULT_KEY_PATH
+    return Path(path).expanduser().exists()