clawrtc 1.4.0 → 1.5.0

package/clawrtc/coinbase_wallet.py

@@ -0,0 +1,234 @@
+"""
+ClawRTC Coinbase Wallet Integration
+Optional module for creating/managing Coinbase Base wallets.
+
+Install with: pip install clawrtc[coinbase]
+"""
+
+import json
+import os
+import sys
+
+# ANSI colors (match cli.py)
+CYAN = "\033[36m"
+GREEN = "\033[32m"
+RED = "\033[31m"
+YELLOW = "\033[33m"
+BOLD = "\033[1m"
+DIM = "\033[2m"
+NC = "\033[0m"
+
+NODE_URL = "https://bulbous-bouffant.metalseed.net"
+
+SWAP_INFO = {
+    "wrtc_contract": "0x5683C10596AaA09AD7F4eF13CAB94b9b74A669c6",
+    "usdc_contract": "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913",
+    "aerodrome_pool": "0x4C2A0b915279f0C22EA766D58F9B815Ded2d2A3F",
+    "swap_url": "https://aerodrome.finance/swap?from=0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913&to=0x5683C10596AaA09AD7F4eF13CAB94b9b74A669c6",
+    "network": "Base (eip155:8453)",
+    "reference_price_usd": 0.10,
+}
+
+INSTALL_DIR = os.path.join(os.path.expanduser("~"), ".clawrtc")
+COINBASE_FILE = os.path.join(INSTALL_DIR, "coinbase_wallet.json")
+
+
+def _load_coinbase_wallet():
+    """Load saved Coinbase wallet data."""
+    if not os.path.exists(COINBASE_FILE):
+        return None
+    try:
+        with open(COINBASE_FILE) as f:
+            return json.load(f)
+    except (json.JSONDecodeError, IOError):
+        return None
+
+
+def _save_coinbase_wallet(data):
+    """Save Coinbase wallet data to disk."""
+    os.makedirs(INSTALL_DIR, exist_ok=True)
+    with open(COINBASE_FILE, "w") as f:
+        json.dump(data, f, indent=2)
+    os.chmod(COINBASE_FILE, 0o600)
+
+
+def coinbase_create(args):
+    """Create a Coinbase Base wallet via AgentKit."""
+    existing = _load_coinbase_wallet()
+    if existing and not getattr(args, "force", False):
+        print(f"\n  {YELLOW}You already have a Coinbase wallet:{NC}")
+        print(f"  {GREEN}{BOLD}{existing['address']}{NC}")
+        print(f"  Network: {existing.get('network', 'Base')}")
+        print(f"\n  To create a new one: clawrtc wallet coinbase create --force\n")
+        return
+
+    # Check for CDP credentials
+    cdp_key_name = os.environ.get("CDP_API_KEY_NAME", "")
+    cdp_key_private = os.environ.get("CDP_API_KEY_PRIVATE_KEY", "")
+
+    if not cdp_key_name or not cdp_key_private:
+        print(f"""
+  {YELLOW}Coinbase CDP credentials not configured.{NC}
+
+  To create a wallet automatically:
+    1. Sign up at {CYAN}https://portal.cdp.coinbase.com{NC}
+    2. Create an API Key
+    3. Set environment variables:
+       export CDP_API_KEY_NAME="organizations/.../apiKeys/..."
+       export CDP_API_KEY_PRIVATE_KEY="-----BEGIN EC PRIVATE KEY-----..."
+
+  Or link an existing Base address manually:
+    clawrtc wallet coinbase link 0xYourBaseAddress
+""")
+        return
+
+    try:
+        from coinbase_agentkit import AgentKit, AgentKitConfig
+
+        print(f"  {CYAN}Creating Coinbase wallet on Base...{NC}")
+
+        config = AgentKitConfig(
+            cdp_api_key_name=cdp_key_name,
+            cdp_api_key_private_key=cdp_key_private,
+            network_id="base-mainnet",
+        )
+        kit = AgentKit(config)
+        wallet = kit.wallet
+        address = wallet.default_address.address_id
+
+        wallet_data = {
+            "address": address,
+            "network": "Base (eip155:8453)",
+            "created": __import__("time").strftime("%Y-%m-%dT%H:%M:%SZ", __import__("time").gmtime()),
+            "method": "agentkit",
+        }
+        _save_coinbase_wallet(wallet_data)
+
+        print(f"""
+  {GREEN}{BOLD}═══════════════════════════════════════════════════════════
+    COINBASE BASE WALLET CREATED
+  ═══════════════════════════════════════════════════════════{NC}
+
+  {GREEN}Base Address:{NC}  {BOLD}{address}{NC}
+  {DIM}Network:{NC}       Base (eip155:8453)
+  {DIM}Saved to:{NC}      {COINBASE_FILE}
+
+  {CYAN}What you can do:{NC}
+    - Receive USDC payments via x402 protocol
+    - Swap USDC → wRTC on Aerodrome DEX
+    - Link to your RustChain miner for cross-chain identity
+    - See swap info: clawrtc wallet coinbase swap-info
+""")
+    except ImportError:
+        print(f"""
+  {RED}coinbase-agentkit not installed.{NC}
+
+  Install it with:
+    pip install clawrtc[coinbase]
+
+  Or: pip install coinbase-agentkit
+""")
+    except Exception as e:
+        print(f"\n  {RED}Failed to create wallet: {e}{NC}\n")
+
+
+def coinbase_show(args):
+    """Show Coinbase Base wallet info."""
+    wallet = _load_coinbase_wallet()
+    if not wallet:
+        print(f"\n  {YELLOW}No Coinbase wallet found.{NC}")
+        print(f"  Create one: clawrtc wallet coinbase create")
+        print(f"  Or link:    clawrtc wallet coinbase link 0xYourAddress\n")
+        return
+
+    print(f"\n  {GREEN}{BOLD}Coinbase Base Wallet{NC}")
+    print(f"  {GREEN}Address:{NC}    {BOLD}{wallet['address']}{NC}")
+    print(f"  {DIM}Network:{NC}    {DIM}{wallet.get('network', 'Base')}{NC}")
+    print(f"  {DIM}Created:{NC}    {DIM}{wallet.get('created', 'unknown')}{NC}")
+    print(f"  {DIM}Method:{NC}     {DIM}{wallet.get('method', 'unknown')}{NC}")
+    print(f"  {DIM}Key File:{NC}   {DIM}{COINBASE_FILE}{NC}")
+    print()
+
+
+def coinbase_link(args):
+    """Link an existing Base address as your Coinbase wallet."""
+    address = getattr(args, "base_address", "")
+    if not address:
+        print(f"\n  {YELLOW}Usage: clawrtc wallet coinbase link 0xYourBaseAddress{NC}\n")
+        return
+
+    if not address.startswith("0x") or len(address) != 42:
+        print(f"\n  {RED}Invalid Base address. Must be 0x + 40 hex characters.{NC}\n")
+        return
+
+    wallet_data = {
+        "address": address,
+        "network": "Base (eip155:8453)",
+        "created": __import__("time").strftime("%Y-%m-%dT%H:%M:%SZ", __import__("time").gmtime()),
+        "method": "manual_link",
+    }
+    _save_coinbase_wallet(wallet_data)
+
+    print(f"\n  {GREEN}Coinbase wallet linked:{NC} {BOLD}{address}{NC}")
+    print(f"  {DIM}Saved to: {COINBASE_FILE}{NC}")
+
+    # Also try to link to RustChain miner
+    rtc_wallet_file = os.path.join(INSTALL_DIR, "wallets", "default.json")
+    if os.path.exists(rtc_wallet_file):
+        try:
+            with open(rtc_wallet_file) as f:
+                rtc = json.load(f)
+            print(f"  {DIM}Linked to RTC wallet: {rtc['address']}{NC}")
+        except Exception:
+            pass
+    print()
+
+
+def coinbase_swap_info(args):
+    """Show USDC→wRTC swap instructions and Aerodrome pool info."""
+    print(f"""
+  {GREEN}{BOLD}USDC → wRTC Swap Guide{NC}
+
+  {CYAN}wRTC Contract (Base):{NC}
+    {BOLD}{SWAP_INFO['wrtc_contract']}{NC}
+
+  {CYAN}USDC Contract (Base):{NC}
+    {BOLD}{SWAP_INFO['usdc_contract']}{NC}
+
+  {CYAN}Aerodrome Pool:{NC}
+    {BOLD}{SWAP_INFO['aerodrome_pool']}{NC}
+
+  {CYAN}Swap URL:{NC}
+    {BOLD}{SWAP_INFO['swap_url']}{NC}
+
+  {CYAN}Network:{NC} {SWAP_INFO['network']}
+  {CYAN}Reference Price:{NC} ~${SWAP_INFO['reference_price_usd']}/wRTC
+
+  {GREEN}How to swap:{NC}
+    1. Get USDC on Base (bridge from Ethereum or buy on Coinbase)
+    2. Go to the Aerodrome swap URL above
+    3. Connect your wallet (MetaMask, Coinbase Wallet, etc.)
+    4. Swap USDC for wRTC
+    5. Bridge wRTC to native RTC at https://bottube.ai/bridge
+
+  {DIM}Or use the RustChain API:{NC}
+    curl -s https://bulbous-bouffant.metalseed.net/wallet/swap-info
+""")
+
+
+def cmd_coinbase(args):
+    """Handle clawrtc wallet coinbase subcommand."""
+    action = getattr(args, "coinbase_action", "show")
+
+    dispatch = {
+        "create": coinbase_create,
+        "show": coinbase_show,
+        "link": coinbase_link,
+        "swap-info": coinbase_swap_info,
+    }
+
+    func = dispatch.get(action)
+    if func:
+        func(args)
+    else:
+        print(f"  Usage: clawrtc wallet coinbase [create|show|link|swap-info]")

package/{data → clawrtc/data}/miner.py

@@ -1,10 +1,19 @@
 #!/usr/bin/env python3
 """
-RustChain Local x86 Miner - Modern Ryzen
+RustChain Local Miner — ClawRTC
+Auto-detects hardware, runs fingerprint checks, earns RTC tokens.
 """
 import os, sys, json, time, hashlib, uuid, requests, socket, subprocess, platform, statistics, re
 from datetime import datetime
 
+# Import fingerprint checks (bundled alongside this file)
+try:
+    sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
+    from fingerprint_checks import validate_all_checks
+    FINGERPRINT_AVAILABLE = True
+except ImportError:
+    FINGERPRINT_AVAILABLE = False
+
 NODE_URL = "https://bulbous-bouffant.metalseed.net"
 BLOCK_TIME = 600  # 10 minutes
 
@@ -17,15 +26,37 @@ class LocalMiner:
         self.attestation_valid_until = 0
         self.last_entropy = {}
 
+        self.fingerprint_data = {}
+
         print("="*70)
-        print("RustChain Local Miner - Ryzen 5 5500")
+        print("ClawRTC Miner — RustChain Network")
         print("="*70)
         print(f"Node: {self.node_url}")
         print(f"Wallet: {self.wallet}")
         print("="*70)
 
+        # Run fingerprint checks on startup
+        if FINGERPRINT_AVAILABLE:
+            print("\nRunning hardware fingerprint checks...")
+            try:
+                all_passed, results = validate_all_checks(include_rom_check=False)
+                self.fingerprint_data = {
+                    "all_passed": all_passed,
+                    "checks": results
+                }
+                if all_passed:
+                    print("All fingerprint checks PASSED")
+                else:
+                    failed = [k for k, v in results.items() if not v.get("passed")]
+                    print(f"WARNING: Fingerprint checks failed: {failed}")
+            except Exception as e:
+                print(f"Fingerprint checks error: {e}")
+                self.fingerprint_data = {"all_passed": False, "error": str(e)}
+        else:
+            print("Fingerprint checks not available (fingerprint_checks.py not found)")
+
     def _gen_wallet(self):
-        data = f"ryzen5-{uuid.uuid4().hex}-{time.time()}"
+        data = f"claw-{uuid.uuid4().hex}-{time.time()}"
         return hashlib.sha256(data.encode()).hexdigest()[:38] + "RTC"
 
     def _run_cmd(self, cmd):
@@ -103,14 +134,42 @@ class LocalMiner:
             "samples_preview": samples[:12],
         }
 
+    def _detect_arch(self):
+        """Detect hardware architecture for RustChain multiplier classification."""
+        machine = platform.machine().lower()
+        cpu = self._run_cmd("lscpu | grep 'Model name' | cut -d: -f2 | xargs") or ""
+        cpu_lower = cpu.lower()
+
+        if "ppc" in machine or "powerpc" in machine:
+            if "g5" in cpu_lower or "970" in cpu_lower:
+                return "x86", "g5"
+            elif "g4" in cpu_lower or "7450" in cpu_lower or "7447" in cpu_lower:
+                return "x86", "g4"
+            elif "g3" in cpu_lower or "750" in cpu_lower:
+                return "x86", "g3"
+            return "powerpc", "powerpc"
+        elif "arm" in machine or "aarch64" in machine:
+            if platform.system() == "Darwin":
+                brand = self._run_cmd("sysctl -n machdep.cpu.brand_string") or ""
+                if any(x in brand.lower() for x in ["m1", "m2", "m3", "m4"]):
+                    return "arm", "apple_silicon"
+            return "arm", "modern"
+        else:
+            if "core 2" in cpu_lower or "core2" in cpu_lower:
+                return "x86", "core2duo"
+            elif "pentium" in cpu_lower:
+                return "x86", "pentium4"
+            return "x86", "modern"
+
     def _get_hw_info(self):
-        """Collect hardware info"""
+        """Collect hardware info with auto-detection."""
+        family, arch = self._detect_arch()
         hw = {
             "platform": platform.system(),
             "machine": platform.machine(),
             "hostname": socket.gethostname(),
-            "family": "x86",
-            "arch": "modern"  # Less than 10 years old
+            "family": family,
+            "arch": arch,
         }
 
         # Get CPU
@@ -161,7 +220,7 @@ class LocalMiner:
         # Submit attestation
         attestation = {
             "miner": self.wallet,
-            "miner_id": f"ryzen5-{self.hw_info['hostname']}",
+            "miner_id": f"claw-{self.hw_info['hostname']}",
             "nonce": nonce,
             "report": {
                 "nonce": nonce,
@@ -174,7 +233,7 @@ class LocalMiner:
             "device": {
                 "family": self.hw_info["family"],
                 "arch": self.hw_info["arch"],
-                "model": "AMD Ryzen 5 5500",
+                "model": self.hw_info.get("cpu", "Unknown"),
                 "cpu": self.hw_info["cpu"],
                 "cores": self.hw_info["cores"],
                 "memory_gb": self.hw_info["memory_gb"]
@@ -182,7 +241,8 @@ class LocalMiner:
             "signals": {
                 "macs": self.hw_info.get("macs", [self.hw_info["mac"]]),
                 "hostname": self.hw_info["hostname"]
-            }
+            },
+            "fingerprint": self.fingerprint_data if self.fingerprint_data else None
         }
 
         try:
@@ -195,8 +255,9 @@ class LocalMiner:
                     self.attestation_valid_until = time.time() + 580
                     print(f"✅ Attestation accepted!")
                     print(f"   CPU: {self.hw_info['cpu']}")
-                    print(f"   Family: x86/modern")
-                    print(f"   Expected Weight: 1.0x")
+                    print(f"   Arch: {self.hw_info['family']}/{self.hw_info['arch']}")
+                    fp_status = "PASSED" if self.fingerprint_data.get("all_passed") else "N/A"
+                    print(f"   Fingerprint: {fp_status}")
                     return True
                 else:
                     print(f"❌ Rejected: {result}")
@@ -219,7 +280,7 @@ class LocalMiner:
 
         payload = {
             "miner_pubkey": self.wallet,
-            "miner_id": f"ryzen5-{self.hw_info['hostname']}",
+            "miner_id": f"claw-{self.hw_info['hostname']}",
             "device": {
                 "family": self.hw_info["family"],
                 "arch": self.hw_info["arch"]

package/clawrtc.egg-info/PKG-INFO

@@ -0,0 +1,102 @@
+Metadata-Version: 2.4
+Name: clawrtc
+Version: 1.5.0
+Summary: ClawRTC — Let your AI agent mine RTC tokens on any modern hardware. Built-in wallet, VM-penalized.
+Author-email: Elyan Labs <scott@elyanlabs.ai>
+License: MIT
+Project-URL: Homepage, https://rustchain.org
+Project-URL: Repository, https://github.com/Scottcjn/Rustchain
+Project-URL: Issues, https://github.com/Scottcjn/Rustchain/issues
+Project-URL: Documentation, https://bottube.ai
+Keywords: clawrtc,ai-agent,miner,rustchain,rtc,openclaw,proof-of-antiquity,wallet,coinbase,x402,base-chain
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Operating System :: MacOS
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Software Development :: Libraries
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: requests>=2.25
+Requires-Dist: cryptography>=41.0
+Provides-Extra: coinbase
+Requires-Dist: coinbase-agentkit>=0.1.0; extra == "coinbase"
+Dynamic: license-file
+
+# ClawRTC — Mine RTC Tokens With Your AI Agent
+
+Your Claw agent can earn **RTC (RustChain Tokens)** by proving it runs on **real hardware**. One command to install, automatic attestation, built-in wallet.
+
+## Quick Start
+
+```bash
+pip install clawrtc
+clawrtc install --wallet my-agent-miner
+clawrtc start
+```
+
+That's it. Your agent is now mining RTC.
+
+## How It Works
+
+1. **Hardware Fingerprinting** — 6 cryptographic checks prove your machine is real hardware (clock drift, cache timing, SIMD identity, thermal drift, instruction jitter, anti-emulation)
+2. **Attestation** — Your agent automatically attests to the RustChain network every few minutes
+3. **Rewards** — RTC tokens accumulate in your wallet each epoch (~10 minutes)
+4. **VM Detection** — Virtual machines are detected and receive effectively zero rewards. **Real iron only.**
+
+## Multipliers
+
+| Hardware | Multiplier | Notes |
+|----------|-----------|-------|
+| Modern x86/ARM | **1.0x** | Standard reward rate |
+| Apple Silicon (M1/M2/M3) | **1.2x** | Slight bonus |
+| PowerPC G5 | **2.0x** | Vintage bonus |
+| PowerPC G4 | **2.5x** | Maximum vintage bonus |
+| **VM/Emulator** | **~0x** | **Detected and penalized** |
+
+## Commands
+
+| Command | Description |
+|---------|-------------|
+| `clawrtc install` | Download miner, create wallet, set up service |
+| `clawrtc start` | Start mining in background |
+| `clawrtc stop` | Stop mining |
+| `clawrtc status` | Check miner + network status |
+| `clawrtc logs` | View miner output |
+| `clawrtc uninstall` | Remove everything |
+
+## What Gets Installed
+
+- Miner scripts from [RustChain repo](https://github.com/Scottcjn/Rustchain)
+- Python virtual environment with `requests` dependency
+- Systemd user service (Linux) or LaunchAgent (macOS)
+- All files in `~/.clawrtc/`
+
+## VM Warning
+
+RustChain uses **Proof-of-Antiquity (PoA)** consensus. The hardware fingerprint system detects:
+
+- QEMU / KVM / VMware / VirtualBox / Xen / Hyper-V
+- Hypervisor CPU flags
+- DMI vendor strings
+- Flattened timing distributions
+
+If you're running in a VM, the miner will install and attest, but your rewards will be effectively zero. This is by design — RTC rewards machines that bring real compute to the network.
+
+## Requirements
+
+- Python 3.8+
+- Linux or macOS (Windows installer coming soon)
+- Real hardware (not a VM)
+
+## Links
+
+- [RustChain Network](https://bottube.ai)
+- [Block Explorer](https://50.28.86.131/explorer)
+- [GitHub](https://github.com/Scottcjn/Rustchain)
+
+## License
+
+MIT — Elyan Labs

package/clawrtc.egg-info/SOURCES.txt

@@ -0,0 +1,15 @@
+LICENSE
+README.md
+pyproject.toml
+clawrtc/__init__.py
+clawrtc/cli.py
+clawrtc/coinbase_wallet.py
+clawrtc.egg-info/PKG-INFO
+clawrtc.egg-info/SOURCES.txt
+clawrtc.egg-info/dependency_links.txt
+clawrtc.egg-info/entry_points.txt
+clawrtc.egg-info/requires.txt
+clawrtc.egg-info/top_level.txt
+clawrtc/data/__init__.py
+clawrtc/data/fingerprint_checks.py
+clawrtc/data/miner.py

package/clawrtc.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

package/clawrtc.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+clawrtc = clawrtc.cli:main

package/clawrtc.egg-info/requires.txt

@@ -0,0 +1,5 @@
+requests>=2.25
+cryptography>=41.0
+
+[coinbase]
+coinbase-agentkit>=0.1.0

package/clawrtc.egg-info/top_level.txt

@@ -0,0 +1 @@
+clawrtc

package/package.json

@@ -1,23 +1,39 @@
 {
   "name": "clawrtc",
-  "version": "1.4.0",
-  "description": "ClawRTC — Mine RTC tokens with your AI agent. Built-in Ed25519 wallet, hardware fingerprinting, VM-penalized.",
-  "bin": {
-    "clawrtc": "./bin/clawrtc.js"
-  },
-  "files": [
-    "bin/",
-    "data/"
+  "version": "1.5.0",
+  "description": "Mine RTC tokens with your AI agent using Proof-of-Antiquity consensus. Coinbase wallet + x402 payments.",
+  "keywords": [
+    "clawrtc",
+    "openclaw",
+    "skill",
+    "ai-agent",
+    "miner",
+    "rustchain",
+    "rtc",
+    "proof-of-antiquity",
+    "hardware-fingerprint",
+    "coinbase",
+    "x402",
+    "base-chain",
+    "wrtc"
   ],
-  "keywords": ["clawrtc", "ai-agent", "miner", "rustchain", "rtc", "openclaw", "proof-of-antiquity", "blockchain", "wallet", "ed25519"],
   "author": "Elyan Labs <scott@elyanlabs.ai>",
   "license": "MIT",
   "homepage": "https://rustchain.org",
   "repository": {
     "type": "git",
-    "url": "https://github.com/Scottcjn/Rustchain"
+    "url": "git+https://github.com/Scottcjn/Rustchain.git"
+  },
+  "bugs": {
+    "url": "https://github.com/Scottcjn/Rustchain/issues"
   },
-  "engines": {
-    "node": ">=14"
+  "claudeSkill": {
+    "name": "clawrtc",
+    "description": "Mine RTC tokens with Proof-of-Antiquity hardware fingerprinting",
+    "invocation": "/clawrtc",
+    "platforms": ["rustchain"],
+    "author": "Elyan Labs",
+    "homepage": "https://rustchain.org",
+    "version": "1.5.0"
   }
 }

package/pyproject.toml

@@ -0,0 +1,42 @@
+[build-system]
+requires = ["setuptools>=64", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "clawrtc"
+version = "1.5.0"
+description = "ClawRTC — Let your AI agent mine RTC tokens on any modern hardware. Built-in wallet, VM-penalized."
+readme = "README.md"
+license = {text = "MIT"}
+authors = [{name = "Elyan Labs", email = "scott@elyanlabs.ai"}]
+requires-python = ">=3.8"
+dependencies = ["requests>=2.25", "cryptography>=41.0"]
+
+keywords = ["clawrtc", "ai-agent", "miner", "rustchain", "rtc", "openclaw", "proof-of-antiquity", "wallet", "coinbase", "x402", "base-chain"]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: POSIX :: Linux",
+    "Operating System :: MacOS",
+    "Programming Language :: Python :: 3",
+    "Topic :: Software Development :: Libraries",
+]
+
+[project.optional-dependencies]
+coinbase = ["coinbase-agentkit>=0.1.0"]
+
+[project.urls]
+Homepage = "https://rustchain.org"
+Repository = "https://github.com/Scottcjn/Rustchain"
+Issues = "https://github.com/Scottcjn/Rustchain/issues"
+Documentation = "https://bottube.ai"
+
+[project.scripts]
+clawrtc = "clawrtc.cli:main"
+
+[tool.setuptools.packages.find]
+include = ["clawrtc*"]
+
+[tool.setuptools.package-data]
+clawrtc = ["data/*.py"]