squidbot 0.1.0__py3-none-any.whl

squidbot/plugins/web3_plugin.py

@@ -0,0 +1,407 @@
+"""
+Web3 Plugin for SquidBot
+
+Provides blockchain wallet functionality:
+- Wallet from mnemonic or random generation
+- Get balance
+- Send CRO
+- Get transaction count
+
+Hooks:
+- before_tool_call: Log and optionally block dangerous transactions
+- after_tool_call: Log transaction results
+"""
+
+import logging
+import os
+from typing import Any
+
+from dotenv import load_dotenv
+
+from ..tools.base import Tool
+from .base import Plugin, PluginApi, PluginManifest
+from .hooks import (AfterToolCallEvent, BeforeToolCallEvent,
+                    BeforeToolCallResult, HookContext, HookName)
+
+logger = logging.getLogger(__name__)
+
+# Load environment
+load_dotenv()
+
+# Configuration from environment
+SQUIDBOT_MNEMONICS = os.environ.get("SQUIDBOT_MNEMONICS", "")
+SQUIDBOT_WALLET_INDEX = int(os.environ.get("SQUIDBOT_WALLET_INDEX", "0"))
+SQUIDBOT_CHAINID = int(os.environ.get("SQUIDBOT_CHAINID", "338"))
+SQUIDBOT_RPC = os.environ.get("SQUIDBOT_RPC", "https://evm-dev-t3.cronos.org")
+
+
+def get_web3():
+    """Get Web3 instance connected to configured RPC."""
+    try:
+        from web3 import Web3
+
+        w3 = Web3(Web3.HTTPProvider(SQUIDBOT_RPC))
+        return w3
+    except ImportError:
+        logger.error("web3 package not installed. Run: pip install web3")
+        raise
+
+
+def get_wallet():
+    """Get wallet from mnemonic or generate random."""
+    try:
+        from eth_account import Account
+
+        Account.enable_unaudited_hdwallet_features()
+
+        mnemonics = SQUIDBOT_MNEMONICS.strip()
+
+        if not mnemonics:
+            # Generate random mnemonic using os.urandom
+            from mnemonic import Mnemonic
+
+            mnemo = Mnemonic("english")
+            entropy = os.urandom(16)  # 128 bits = 12 words
+            mnemonics = mnemo.to_mnemonic(entropy)
+            logger.info("Generated random wallet (mnemonic not configured)")
+            logger.info(f"Random mnemonic: {mnemonics}")
+            logger.warning("Set SQUIDBOT_MNEMONICS in .env to use a persistent wallet")
+
+        # Derive account from mnemonic with wallet index
+        account = Account.from_mnemonic(
+            mnemonics, account_path=f"m/44'/60'/0'/0/{SQUIDBOT_WALLET_INDEX}"
+        )
+        return account, mnemonics
+
+    except ImportError as e:
+        logger.error(f"Required package not installed: {e}")
+        logger.error("Run: pip install web3 mnemonic")
+        raise
+
+
+class WalletInfoTool(Tool):
+    """Get wallet address and basic info."""
+
+    @property
+    def name(self) -> str:
+        return "wallet_info"
+
+    @property
+    def description(self) -> str:
+        return "Get the wallet address and chain information"
+
+    @property
+    def parameters(self) -> dict:
+        return {"type": "object", "properties": {}, "required": []}
+
+    async def execute(self, **kwargs) -> Any:
+        try:
+            account, _ = get_wallet()
+            w3 = get_web3()
+
+            return {
+                "success": True,
+                "address": account.address,
+                "chain_id": SQUIDBOT_CHAINID,
+                "rpc_url": SQUIDBOT_RPC,
+                "wallet_index": SQUIDBOT_WALLET_INDEX,
+                "connected": w3.is_connected(),
+            }
+        except Exception as e:
+            return {"success": False, "error": str(e)}
+
+
+class GetBalanceTool(Tool):
+    """Get wallet balance in CRO."""
+
+    @property
+    def name(self) -> str:
+        return "get_balance"
+
+    @property
+    def description(self) -> str:
+        return "Get the CRO balance of the wallet or a specified address"
+
+    @property
+    def parameters(self) -> dict:
+        return {
+            "type": "object",
+            "properties": {
+                "address": {
+                    "type": "string",
+                    "description": "Address to check balance (optional, defaults to wallet address)",
+                }
+            },
+            "required": [],
+        }
+
+    async def execute(self, address: str = "", **kwargs) -> Any:
+        try:
+            w3 = get_web3()
+
+            if not address:
+                account, _ = get_wallet()
+                address = account.address
+
+            # Validate address
+            if not w3.is_address(address):
+                return {"success": False, "error": f"Invalid address: {address}"}
+
+            checksum_address = w3.to_checksum_address(address)
+            balance_wei = w3.eth.get_balance(checksum_address)
+            balance_cro = w3.from_wei(balance_wei, "ether")
+
+            return {
+                "success": True,
+                "address": checksum_address,
+                "balance_wei": str(balance_wei),
+                "balance_cro": str(balance_cro),
+                "unit": "CRO",
+            }
+        except Exception as e:
+            return {"success": False, "error": str(e)}
+
+
+class SendCROTool(Tool):
+    """Send CRO to an address."""
+
+    @property
+    def name(self) -> str:
+        return "send_cro"
+
+    @property
+    def description(self) -> str:
+        return "Send CRO to a specified address"
+
+    @property
+    def parameters(self) -> dict:
+        return {
+            "type": "object",
+            "properties": {
+                "to_address": {
+                    "type": "string",
+                    "description": "Recipient address",
+                },
+                "amount": {
+                    "type": "string",
+                    "description": "Amount of CRO to send (e.g., '1.5')",
+                },
+            },
+            "required": ["to_address", "amount"],
+        }
+
+    async def execute(self, to_address: str, amount: str, **kwargs) -> Any:
+        try:
+            w3 = get_web3()
+            account, _ = get_wallet()
+
+            # Validate recipient address
+            if not w3.is_address(to_address):
+                return {"success": False, "error": f"Invalid address: {to_address}"}
+
+            to_checksum = w3.to_checksum_address(to_address)
+            amount_wei = w3.to_wei(float(amount), "ether")
+
+            # Get current nonce
+            nonce = w3.eth.get_transaction_count(account.address)
+
+            # Build transaction
+            tx = {
+                "nonce": nonce,
+                "to": to_checksum,
+                "value": amount_wei,
+                "gas": 21000,  # Standard ETH transfer
+                "gasPrice": w3.eth.gas_price,
+                "chainId": SQUIDBOT_CHAINID,
+            }
+
+            # Sign and send
+            signed_tx = w3.eth.account.sign_transaction(tx, account.key)
+            tx_hash = w3.eth.send_raw_transaction(signed_tx.raw_transaction)
+
+            return {
+                "success": True,
+                "tx_hash": tx_hash.hex(),
+                "from": account.address,
+                "to": to_checksum,
+                "amount_cro": amount,
+                "amount_wei": str(amount_wei),
+                "chain_id": SQUIDBOT_CHAINID,
+            }
+        except Exception as e:
+            return {"success": False, "error": str(e)}
+
+
+class GetTxCountTool(Tool):
+    """Get transaction count (nonce) for an address."""
+
+    @property
+    def name(self) -> str:
+        return "get_tx_count"
+
+    @property
+    def description(self) -> str:
+        return "Get the transaction count (nonce) for the wallet or a specified address"
+
+    @property
+    def parameters(self) -> dict:
+        return {
+            "type": "object",
+            "properties": {
+                "address": {
+                    "type": "string",
+                    "description": "Address to check (optional, defaults to wallet address)",
+                }
+            },
+            "required": [],
+        }
+
+    async def execute(self, address: str = "", **kwargs) -> Any:
+        try:
+            w3 = get_web3()
+
+            if not address:
+                account, _ = get_wallet()
+                address = account.address
+
+            # Validate address
+            if not w3.is_address(address):
+                return {"success": False, "error": f"Invalid address: {address}"}
+
+            checksum_address = w3.to_checksum_address(address)
+            tx_count = w3.eth.get_transaction_count(checksum_address)
+
+            return {
+                "success": True,
+                "address": checksum_address,
+                "transaction_count": tx_count,
+                "nonce": tx_count,  # Alias for clarity
+            }
+        except Exception as e:
+            return {"success": False, "error": str(e)}
+
+
+class Web3Plugin(Plugin):
+    """Web3 blockchain plugin for SquidBot."""
+
+    @property
+    def manifest(self) -> PluginManifest:
+        return PluginManifest(
+            id="web3",
+            name="Web3 Plugin",
+            description="Blockchain wallet functionality for Cronos chain",
+            version="1.0.0",
+            author="SquidBot",
+            config_schema={
+                "type": "object",
+                "properties": {
+                    "SQUIDBOT_MNEMONICS": {
+                        "type": "string",
+                        "description": "BIP39 mnemonic phrase (12 or 24 words)",
+                    },
+                    "SQUIDBOT_WALLET_INDEX": {
+                        "type": "integer",
+                        "description": "HD wallet derivation index",
+                        "default": 0,
+                    },
+                    "SQUIDBOT_CHAINID": {
+                        "type": "integer",
+                        "description": "Blockchain chain ID",
+                        "default": 338,
+                    },
+                    "SQUIDBOT_RPC": {
+                        "type": "string",
+                        "description": "RPC endpoint URL",
+                        "default": "https://evm-dev-t3.cronos.org",
+                    },
+                },
+            },
+        )
+
+    def get_tools(self) -> list[Tool]:
+        return [
+            WalletInfoTool(),
+            GetBalanceTool(),
+            SendCROTool(),
+            GetTxCountTool(),
+        ]
+
+    def register_hooks(self, api: PluginApi) -> None:
+        """Register hooks for transaction monitoring."""
+
+        # Hook: Before tool call - monitor and optionally block transactions
+        async def on_before_tool_call(
+            event: BeforeToolCallEvent, ctx: HookContext
+        ) -> BeforeToolCallResult | None:
+            # Only interested in web3 tools
+            if event.tool_name not in (
+                "send_cro",
+                "get_balance",
+                "wallet_info",
+                "get_tx_count",
+            ):
+                return None
+
+            logger.info(f"[Web3 Hook] Before {event.tool_name}: {event.params}")
+
+            # Example: Block large transactions (over 100 CRO)
+            if event.tool_name == "send_cro":
+                amount = float(event.params.get("amount", 0))
+                if amount > 100:
+                    logger.warning(
+                        f"[Web3 Hook] Blocking large transaction: {amount} CRO"
+                    )
+                    return BeforeToolCallResult(
+                        block=True,
+                        block_reason=f"Transaction amount {amount} CRO exceeds limit of 100 CRO",
+                    )
+
+            return None
+
+        # Hook: After tool call - log results
+        async def on_after_tool_call(
+            event: AfterToolCallEvent, ctx: HookContext
+        ) -> None:
+            # Only interested in web3 tools
+            if event.tool_name not in (
+                "send_cro",
+                "get_balance",
+                "wallet_info",
+                "get_tx_count",
+            ):
+                return
+
+            if event.error:
+                logger.error(f"[Web3 Hook] {event.tool_name} failed: {event.error}")
+            else:
+                logger.info(
+                    f"[Web3 Hook] {event.tool_name} completed in {event.duration_ms:.2f}ms"
+                )
+
+                # Log transaction hash for send_cro
+                if event.tool_name == "send_cro" and isinstance(event.result, dict):
+                    tx_hash = event.result.get("tx_hash")
+                    if tx_hash:
+                        logger.info(f"[Web3 Hook] Transaction hash: {tx_hash}")
+
+        # Register hooks with priority
+        api.on(HookName.BEFORE_TOOL_CALL, on_before_tool_call, priority=10)
+        api.on(HookName.AFTER_TOOL_CALL, on_after_tool_call, priority=10)
+
+    def activate(self) -> None:
+        logger.info(f"Web3 Plugin activated - Chain ID: {SQUIDBOT_CHAINID}")
+        logger.info(f"RPC: {SQUIDBOT_RPC}")
+
+        # Log wallet status (not the actual mnemonic for security)
+        if SQUIDBOT_MNEMONICS:
+            logger.info("Using configured mnemonic")
+        else:
+            logger.info("No mnemonic configured - will generate random wallet")
+
+    def deactivate(self) -> None:
+        logger.info("Web3 Plugin deactivated")
+
+
+def get_plugin() -> Plugin:
+    """Factory function to create plugin instance."""
+    return Web3Plugin()

squidbot/scheduler.py

@@ -0,0 +1,214 @@
+"""Scheduler for proactive messaging - cron jobs and heartbeat."""
+
+import asyncio
+import logging
+from datetime import datetime, timedelta
+from typing import Awaitable, Callable
+
+from apscheduler.schedulers.asyncio import AsyncIOScheduler
+from apscheduler.triggers.cron import CronTrigger
+from apscheduler.triggers.interval import IntervalTrigger
+
+from .config import HEARTBEAT_INTERVAL_MINUTES
+from .tools.cron import load_cron_jobs, save_cron_jobs
+
+logger = logging.getLogger(__name__)
+
+
+class Scheduler:
+    """Manages scheduled tasks and heartbeat."""
+
+    def __init__(
+        self,
+        send_message: Callable[[str], Awaitable[None]],
+        run_agent: Callable[[str], Awaitable[str]],
+        chat_id: int | None = None,
+    ):
+        self.scheduler = AsyncIOScheduler()
+        self.send_message = send_message
+        self.run_agent = run_agent
+        self.chat_id = chat_id  # Default chat to send proactive messages
+        self._started = False
+
+    def start(self):
+        """Start the scheduler."""
+        if self._started:
+            return
+
+        # Load and schedule cron jobs
+        self._load_cron_jobs()
+
+        # Add heartbeat job
+        if HEARTBEAT_INTERVAL_MINUTES > 0:
+            self.scheduler.add_job(
+                self._heartbeat,
+                IntervalTrigger(minutes=HEARTBEAT_INTERVAL_MINUTES),
+                id="heartbeat",
+                replace_existing=True,
+            )
+            logger.info(
+                f"Heartbeat scheduled every {HEARTBEAT_INTERVAL_MINUTES} minutes"
+            )
+
+        # Check one-time jobs every minute
+        self.scheduler.add_job(
+            self._check_one_time_jobs,
+            IntervalTrigger(minutes=1),
+            id="one_time_checker",
+            replace_existing=True,
+        )
+
+        # Check interval jobs every 5 seconds
+        self.scheduler.add_job(
+            self._check_interval_jobs,
+            IntervalTrigger(seconds=5),
+            id="interval_checker",
+            replace_existing=True,
+        )
+
+        self.scheduler.start()
+        self._started = True
+        logger.info("Scheduler started")
+
+    def stop(self):
+        """Stop the scheduler."""
+        if self._started:
+            self.scheduler.shutdown()
+            self._started = False
+
+    def _load_cron_jobs(self):
+        """Load cron jobs from storage and schedule them."""
+        jobs = load_cron_jobs()
+        for job in jobs:
+            if job.get("type") == "cron" and job.get("enabled", True):
+                try:
+                    self.scheduler.add_job(
+                        self._run_cron_job,
+                        CronTrigger.from_crontab(job["cron_expression"]),
+                        id=f"cron_{job['id']}",
+                        args=[job],
+                        replace_existing=True,
+                    )
+                    logger.info(
+                        f"Scheduled cron job {job['id']}: {job['cron_expression']}"
+                    )
+                except Exception as e:
+                    logger.error(f"Failed to schedule job {job['id']}: {e}")
+
+    async def _run_cron_job(self, job: dict):
+        """Execute a cron job by running the agent."""
+        logger.info(f"Running cron job {job['id']}: {job['message']}")
+        try:
+            # Run agent to actually perform the task
+            response = await self.run_agent(job["message"])
+            await self.send_message(f"[Scheduled Task]\n{response}")
+        except Exception as e:
+            logger.error(f"Failed to run cron job: {e}")
+            await self.send_message(
+                f"[Scheduled Task Failed] {job['message']}\nError: {str(e)}"
+            )
+
+    async def _check_one_time_jobs(self):
+        """Check and execute one-time jobs that are due."""
+        jobs = load_cron_jobs()
+        now = datetime.now()
+        updated = False
+
+        for job in jobs:
+            if job.get("type") != "one_time" or not job.get("enabled", True):
+                continue
+
+            trigger_at = datetime.fromisoformat(job["trigger_at"])
+            if trigger_at <= now:
+                logger.info(f"Triggering one-time job {job['id']}: {job['message']}")
+                try:
+                    # Run agent to actually perform the task
+                    response = await self.run_agent(job["message"])
+                    await self.send_message(f"[Reminder]\n{response}")
+                    job["enabled"] = False  # Disable after triggering
+                    updated = True
+                except Exception as e:
+                    logger.error(f"Failed to run reminder job: {e}")
+                    await self.send_message(
+                        f"[Reminder Failed] {job['message']}\nError: {str(e)}"
+                    )
+                    job["enabled"] = False
+                    updated = True
+
+        if updated:
+            save_cron_jobs(jobs)
+
+    async def _check_interval_jobs(self):
+        """Check and execute interval jobs that are due."""
+        jobs = load_cron_jobs()
+        now = datetime.now()
+        updated = False
+
+        for job in jobs:
+            if job.get("type") != "interval" or not job.get("enabled", True):
+                continue
+
+            next_trigger = datetime.fromisoformat(
+                job.get("next_trigger", now.isoformat())
+            )
+            if next_trigger <= now:
+                logger.info(f"Triggering interval job {job['id']}: {job['message']}")
+                try:
+                    # Run agent to actually perform the task
+                    response = await self.run_agent(job["message"])
+                    await self.send_message(f"[Interval Task]\n{response}")
+
+                    # Schedule next trigger
+                    interval = job.get("interval_seconds", 60)
+                    job["next_trigger"] = (
+                        datetime.now() + timedelta(seconds=interval)
+                    ).isoformat()
+                    updated = True
+                except Exception as e:
+                    logger.error(f"Failed to run interval job: {e}")
+                    await self.send_message(
+                        f"[Interval Task Failed] {job['message']}\nError: {str(e)}"
+                    )
+                    # Still schedule next trigger
+                    interval = job.get("interval_seconds", 60)
+                    job["next_trigger"] = (
+                        datetime.now() + timedelta(seconds=interval)
+                    ).isoformat()
+                    updated = True
+
+        if updated:
+            save_cron_jobs(jobs)
+
+    async def _heartbeat(self):
+        """Periodic heartbeat - ask agent if there's anything to report."""
+        if not self.chat_id:
+            return
+
+        logger.info("Running heartbeat check")
+        try:
+            # Ask the agent if there's anything to proactively share
+            response = await self.run_agent(
+                "This is a periodic heartbeat check. "
+                "If there's anything important to proactively share with the user "
+                "(e.g., completed background tasks, reminders, or relevant updates), "
+                "please say it. Otherwise, respond with just 'HEARTBEAT_OK' and nothing else."
+            )
+
+            if response.strip() != "HEARTBEAT_OK":
+                await self.send_message(response)
+        except Exception as e:
+            logger.error(f"Heartbeat error: {e}")
+
+    def reload_jobs(self):
+        """Reload cron jobs from storage."""
+        # Remove existing cron jobs
+        for job in self.scheduler.get_jobs():
+            if job.id.startswith("cron_"):
+                job.remove()
+
+        # Reload
+        self._load_cron_jobs()
+
+    def set_chat_id(self, chat_id: int):
+        """Set the default chat ID for proactive messages."""
+        self.chat_id = chat_id