Add blockchain event bridge service with smart contract event integration

- Phase 1: Core bridge service with gossip broker subscription
- Phase 2: Smart contract event integration via eth_getLogs RPC endpoint
- Add contract event subscriber for AgentStaking, PerformanceVerifier, Marketplace, Bounty, CrossChainBridge
- Add contract event handlers in agent_daemon.py and marketplace.py
- Add systemd service file for blockchain-event-bridge
- Update blockchain node router.py with eth_getLogs endpoint
- Add configuration for contract addresses
- Add tests for contract subscriber and handlers (27 tests passing)

apps/blockchain-event-bridge/src/blockchain_event_bridge/action_handlers/__init__.py

@@ -0,0 +1,7 @@
+"""Action handler modules for OpenClaw agent triggers."""
+
+from .coordinator_api import CoordinatorAPIHandler
+from .agent_daemon import AgentDaemonHandler
+from .marketplace import MarketplaceHandler
+
+__all__ = ["CoordinatorAPIHandler", "AgentDaemonHandler", "MarketplaceHandler"]

apps/blockchain-event-bridge/src/blockchain_event_bridge/action_handlers/agent_daemon.py

@@ -0,0 +1,246 @@
+"""Agent daemon action handler for triggering autonomous agent responses."""
+
+import httpx
+import logging
+from typing import Any, Dict
+
+logger = logging.getLogger(__name__)
+
+
+class AgentDaemonHandler:
+    """Handles actions that trigger the agent daemon to process transactions."""
+
+    def __init__(self, blockchain_rpc_url: str) -> None:
+        self.blockchain_rpc_url = blockchain_rpc_url.rstrip("/")
+        self._client: Optional[httpx.AsyncClient] = None
+
+    async def _get_client(self) -> httpx.AsyncClient:
+        """Get or create HTTP client."""
+        if self._client is None:
+            self._client = httpx.AsyncClient(
+                base_url=self.blockchain_rpc_url,
+                timeout=30.0,
+            )
+        return self._client
+
+    async def close(self) -> None:
+        """Close HTTP client."""
+        if self._client:
+            await self._client.aclose()
+            self._client = None
+
+    async def handle_transaction(self, tx_data: Dict[str, Any]) -> None:
+        """Handle a transaction that may require agent daemon response."""
+        tx_hash = tx_data.get("hash", "unknown")
+        tx_type = tx_data.get("type", "unknown")
+        recipient = tx_data.get("to")
+
+        logger.info(f"Checking transaction {tx_hash} for agent daemon trigger")
+
+        # Check if this is a message to an agent wallet
+        if self._is_agent_transaction(tx_data):
+            await self._notify_agent_daemon(tx_data)
+
+    def _is_agent_transaction(self, tx_data: Dict[str, Any]) -> bool:
+        """Check if transaction is addressed to an agent wallet."""
+        # In a real implementation, this would check against a registry of agent addresses
+        # For now, we'll check if the transaction has a payload that looks like an agent message
+        payload = tx_data.get("payload", {})
+
+        # Check for agent message indicators
+        if isinstance(payload, dict):
+            # Check for trigger message or agent-specific fields
+            if "trigger" in payload or "agent" in payload or "command" in payload:
+                return True
+
+        return False
+
+    async def _notify_agent_daemon(self, tx_data: Dict[str, Any]) -> None:
+        """Notify agent daemon about a transaction requiring processing."""
+        try:
+            # The agent daemon currently polls the blockchain database directly
+            # This handler could be enhanced to send a direct notification
+            # For now, we'll log that the agent daemon should pick this up on its next poll
+
+            tx_hash = tx_data.get("hash", "unknown")
+            recipient = tx_data.get("to")
+
+            logger.info(f"Agent daemon should process transaction {tx_hash} to {recipient}")
+
+            # Future enhancement: send direct notification via agent-coordinator API
+            # client = await self._get_client()
+            # response = await client.post(f"/v1/agents/{recipient}/notify", json=tx_data)
+
+        except Exception as e:
+            logger.error(f"Error notifying agent daemon: {e}", exc_info=True)
+
+    # Phase 2: Contract event handlers
+    async def handle_staking_event(self, event_log: Dict[str, Any]) -> None:
+        """Handle AgentStaking contract event."""
+        event_type = event_log.get("topics", [""])[0] if event_log.get("topics") else "Unknown"
+        logger.info(f"Handling staking event: {event_type}")
+
+        # Route based on event type
+        if "StakeCreated" in event_type:
+            await self._handle_stake_created(event_log)
+        elif "RewardsDistributed" in event_type:
+            await self._handle_rewards_distributed(event_log)
+        elif "AgentTierUpdated" in event_type:
+            await self._handle_agent_tier_updated(event_log)
+
+    async def _handle_stake_created(self, event_log: Dict[str, Any]) -> None:
+        """Handle StakeCreated event."""
+        try:
+            # Extract event data
+            data = event_log.get("data", "{}")
+            logger.info(f"StakeCreated event: {data}")
+
+            # Call coordinator API to update agent reputation
+            # This would call the reputation service to update agent tier based on stake
+            logger.info("Would call coordinator API reputation service to update agent stake")
+
+        except Exception as e:
+            logger.error(f"Error handling StakeCreated event: {e}", exc_info=True)
+
+    async def _handle_rewards_distributed(self, event_log: Dict[str, Any]) -> None:
+        """Handle RewardsDistributed event."""
+        try:
+            data = event_log.get("data", "{}")
+            logger.info(f"RewardsDistributed event: {data}")
+
+            # Call coordinator API to update agent rewards
+            logger.info("Would call coordinator API to update agent rewards")
+
+        except Exception as e:
+            logger.error(f"Error handling RewardsDistributed event: {e}", exc_info=True)
+
+    async def _handle_agent_tier_updated(self, event_log: Dict[str, Any]) -> None:
+        """Handle AgentTierUpdated event."""
+        try:
+            data = event_log.get("data", "{}")
+            logger.info(f"AgentTierUpdated event: {data}")
+
+            # Call coordinator API to update agent tier
+            logger.info("Would call coordinator API reputation service to update agent tier")
+
+        except Exception as e:
+            logger.error(f"Error handling AgentTierUpdated event: {e}", exc_info=True)
+
+    async def handle_performance_event(self, event_log: Dict[str, Any]) -> None:
+        """Handle PerformanceVerifier contract event."""
+        event_type = event_log.get("topics", [""])[0] if event_log.get("topics") else "Unknown"
+        logger.info(f"Handling performance event: {event_type}")
+
+        # Route based on event type
+        if "PerformanceVerified" in event_type:
+            await self._handle_performance_verified(event_log)
+        elif "PenaltyApplied" in event_type:
+            await self._handle_penalty_applied(event_log)
+        elif "RewardIssued" in event_type:
+            await self._handle_reward_issued(event_log)
+
+    async def _handle_performance_verified(self, event_log: Dict[str, Any]) -> None:
+        """Handle PerformanceVerified event."""
+        try:
+            data = event_log.get("data", "{}")
+            logger.info(f"PerformanceVerified event: {data}")
+
+            # Call coordinator API to update performance metrics
+            logger.info("Would call coordinator API performance service to update metrics")
+
+        except Exception as e:
+            logger.error(f"Error handling PerformanceVerified event: {e}", exc_info=True)
+
+    async def _handle_penalty_applied(self, event_log: Dict[str, Any]) -> None:
+        """Handle PenaltyApplied event."""
+        try:
+            data = event_log.get("data", "{}")
+            logger.info(f"PenaltyApplied event: {data}")
+
+            # Call coordinator API to update agent penalties
+            logger.info("Would call coordinator API performance service to apply penalty")
+
+        except Exception as e:
+            logger.error(f"Error handling PenaltyApplied event: {e}", exc_info=True)
+
+    async def _handle_reward_issued(self, event_log: Dict[str, Any]) -> None:
+        """Handle RewardIssued event."""
+        try:
+            data = event_log.get("data", "{}")
+            logger.info(f"RewardIssued event: {data}")
+
+            # Call coordinator API to update agent rewards
+            logger.info("Would call coordinator API performance service to issue reward")
+
+        except Exception as e:
+            logger.error(f"Error handling RewardIssued event: {e}", exc_info=True)
+
+    async def handle_bounty_event(self, event_log: Dict[str, Any]) -> None:
+        """Handle BountyIntegration contract event."""
+        event_type = event_log.get("topics", [""])[0] if event_log.get("topics") else "Unknown"
+        logger.info(f"Handling bounty event: {event_type}")
+
+        # Route based on event type
+        if "BountyCreated" in event_type:
+            await self._handle_bounty_created(event_log)
+        elif "BountyCompleted" in event_type:
+            await self._handle_bounty_completed(event_log)
+
+    async def _handle_bounty_created(self, event_log: Dict[str, Any]) -> None:
+        """Handle BountyCreated event."""
+        try:
+            data = event_log.get("data", "{}")
+            logger.info(f"BountyCreated event: {data}")
+
+            # Call coordinator API to sync new bounty
+            logger.info("Would call coordinator API bounty service to sync bounty")
+
+        except Exception as e:
+            logger.error(f"Error handling BountyCreated event: {e}", exc_info=True)
+
+    async def _handle_bounty_completed(self, event_log: Dict[str, Any]) -> None:
+        """Handle BountyCompleted event."""
+        try:
+            data = event_log.get("data", "{}")
+            logger.info(f"BountyCompleted event: {data}")
+
+            # Call coordinator API to complete bounty
+            logger.info("Would call coordinator API bounty service to complete bounty")
+
+        except Exception as e:
+            logger.error(f"Error handling BountyCompleted event: {e}", exc_info=True)
+
+    async def handle_bridge_event(self, event_log: Dict[str, Any]) -> None:
+        """Handle CrossChainBridge contract event."""
+        event_type = event_log.get("topics", [""])[0] if event_log.get("topics") else "Unknown"
+        logger.info(f"Handling bridge event: {event_type}")
+
+        # Route based on event type
+        if "BridgeInitiated" in event_type:
+            await self._handle_bridge_initiated(event_log)
+        elif "BridgeCompleted" in event_type:
+            await self._handle_bridge_completed(event_log)
+
+    async def _handle_bridge_initiated(self, event_log: Dict[str, Any]) -> None:
+        """Handle BridgeInitiated event."""
+        try:
+            data = event_log.get("data", "{}")
+            logger.info(f"BridgeInitiated event: {data}")
+
+            # Call coordinator API to track bridge
+            logger.info("Would call coordinator API cross-chain service to track bridge")
+
+        except Exception as e:
+            logger.error(f"Error handling BridgeInitiated event: {e}", exc_info=True)
+
+    async def _handle_bridge_completed(self, event_log: Dict[str, Any]) -> None:
+        """Handle BridgeCompleted event."""
+        try:
+            data = event_log.get("data", "{}")
+            logger.info(f"BridgeCompleted event: {data}")
+
+            # Call coordinator API to complete bridge
+            logger.info("Would call coordinator API cross-chain service to complete bridge")
+
+        except Exception as e:
+            logger.error(f"Error handling BridgeCompleted event: {e}", exc_info=True)

apps/blockchain-event-bridge/src/blockchain_event_bridge/action_handlers/coordinator_api.py

@@ -0,0 +1,125 @@
+"""Coordinator API action handler for triggering OpenClaw agent actions."""
+
+import httpx
+import logging
+from typing import Any, Dict, List, Optional
+
+logger = logging.getLogger(__name__)
+
+
+class CoordinatorAPIHandler:
+    """Handles actions that trigger coordinator API endpoints."""
+
+    def __init__(self, base_url: str, api_key: Optional[str] = None) -> None:
+        self.base_url = base_url.rstrip("/")
+        self.api_key = api_key
+        self._client: Optional[httpx.AsyncClient] = None
+
+    async def _get_client(self) -> httpx.AsyncClient:
+        """Get or create HTTP client."""
+        if self._client is None:
+            headers = {}
+            if self.api_key:
+                headers["Authorization"] = f"Bearer {self.api_key}"
+
+            self._client = httpx.AsyncClient(
+                base_url=self.base_url,
+                headers=headers,
+                timeout=30.0,
+            )
+        return self._client
+
+    async def close(self) -> None:
+        """Close HTTP client."""
+        if self._client:
+            await self._client.aclose()
+            self._client = None
+
+    async def handle_block(self, block_data: Dict[str, Any], transactions: List[Dict[str, Any]]) -> None:
+        """Handle a new block by triggering coordinator API actions."""
+        logger.info(f"Handling block {block_data.get('height')} with {len(transactions)} transactions")
+
+        # Filter relevant transactions (AI jobs, agent messages, etc.)
+        for tx in transactions:
+            await self.handle_transaction(tx)
+
+    async def handle_transaction(self, tx_data: Dict[str, Any]) -> None:
+        """Handle a single transaction."""
+        tx_type = tx_data.get("type", "unknown")
+        tx_hash = tx_data.get("hash", "unknown")
+
+        logger.info(f"Handling transaction {tx_hash} of type {tx_type}")
+
+        # Route based on transaction type
+        if tx_type == "ai_job":
+            await self._trigger_ai_job_processing(tx_data)
+        elif tx_type == "agent_message":
+            await self._trigger_agent_message_processing(tx_data)
+        elif tx_type == "marketplace":
+            await self._trigger_marketplace_update(tx_data)
+
+    async def _trigger_ai_job_processing(self, tx_data: Dict[str, Any]) -> None:
+        """Trigger AI job processing via coordinator API."""
+        try:
+            client = await self._get_client()
+
+            # Extract job details from transaction payload
+            payload = tx_data.get("payload", {})
+            job_id = payload.get("job_id")
+
+            if job_id:
+                # Notify coordinator about new AI job
+                response = await client.post(f"/v1/ai-jobs/{job_id}/notify", json=tx_data)
+                response.raise_for_status()
+                logger.info(f"Successfully notified coordinator about AI job {job_id}")
+
+        except httpx.HTTPError as e:
+            logger.error(f"HTTP error triggering AI job processing: {e}")
+        except Exception as e:
+            logger.error(f"Error triggering AI job processing: {e}", exc_info=True)
+
+    async def _trigger_agent_message_processing(self, tx_data: Dict[str, Any]) -> None:
+        """Trigger agent message processing via coordinator API."""
+        try:
+            client = await self._get_client()
+
+            # Extract message details
+            payload = tx_data.get("payload", {})
+            recipient = tx_data.get("to")
+
+            if recipient:
+                # Notify coordinator about agent message
+                response = await client.post(
+                    f"/v1/agents/{recipient}/message",
+                    json={"transaction": tx_data, "payload": payload}
+                )
+                response.raise_for_status()
+                logger.info(f"Successfully notified coordinator about message to {recipient}")
+
+        except httpx.HTTPError as e:
+            logger.error(f"HTTP error triggering agent message processing: {e}")
+        except Exception as e:
+            logger.error(f"Error triggering agent message processing: {e}", exc_info=True)
+
+    async def _trigger_marketplace_update(self, tx_data: Dict[str, Any]) -> None:
+        """Trigger marketplace state update via coordinator API."""
+        try:
+            client = await self._get_client()
+
+            # Extract marketplace details
+            payload = tx_data.get("payload", {})
+            listing_id = payload.get("listing_id")
+
+            if listing_id:
+                # Update marketplace state
+                response = await client.post(
+                    f"/v1/marketplace/{listing_id}/sync",
+                    json={"transaction": tx_data}
+                )
+                response.raise_for_status()
+                logger.info(f"Successfully updated marketplace listing {listing_id}")
+
+        except httpx.HTTPError as e:
+            logger.error(f"HTTP error triggering marketplace update: {e}")
+        except Exception as e:
+            logger.error(f"Error triggering marketplace update: {e}", exc_info=True)

apps/blockchain-event-bridge/src/blockchain_event_bridge/action_handlers/marketplace.py

@@ -0,0 +1,119 @@
+"""Marketplace action handler for triggering marketplace state updates."""
+
+import httpx
+import logging
+from typing import Any, Dict, List
+
+logger = logging.getLogger(__name__)
+
+
+class MarketplaceHandler:
+    """Handles actions that trigger marketplace state updates."""
+
+    def __init__(self, coordinator_api_url: str, api_key: str | None = None) -> None:
+        self.base_url = coordinator_api_url.rstrip("/")
+        self.api_key = api_key
+        self._client: httpx.AsyncClient | None = None
+
+    async def _get_client(self) -> httpx.AsyncClient:
+        """Get or create HTTP client."""
+        if self._client is None:
+            headers = {}
+            if self.api_key:
+                headers["Authorization"] = f"Bearer {self.api_key}"
+
+            self._client = httpx.AsyncClient(
+                base_url=self.base_url,
+                headers=headers,
+                timeout=30.0,
+            )
+        return self._client
+
+    async def close(self) -> None:
+        """Close HTTP client."""
+        if self._client:
+            await self._client.aclose()
+            self._client = None
+
+    async def handle_block(self, block_data: Dict[str, Any], transactions: List[Dict[str, Any]]) -> None:
+        """Handle a new block by updating marketplace state."""
+        logger.info(f"Processing block {block_data.get('height')} for marketplace updates")
+
+        # Filter marketplace-related transactions
+        marketplace_txs = self._filter_marketplace_transactions(transactions)
+
+        if marketplace_txs:
+            await self._sync_marketplace_state(marketplace_txs)
+
+    def _filter_marketplace_transactions(self, transactions: List[Dict[str, Any]]) -> List[Dict[str, Any]]:
+        """Filter transactions that affect marketplace state."""
+        marketplace_txs = []
+
+        for tx in transactions:
+            tx_type = tx.get("type", "unknown")
+            payload = tx.get("payload", {})
+
+            # Check for marketplace-related transaction types
+            if tx_type in ["marketplace", "listing", "purchase", "service"]:
+                marketplace_txs.append(tx)
+            elif isinstance(payload, dict):
+                # Check for marketplace-related payload fields
+                if any(key in payload for key in ["listing_id", "service_id", "marketplace"]):
+                    marketplace_txs.append(tx)
+
+        return marketplace_txs
+
+    async def _sync_marketplace_state(self, transactions: List[Dict[str, Any]]) -> None:
+        """Synchronize marketplace state with blockchain."""
+        try:
+            client = await self._get_client()
+
+            # Send batch of marketplace transactions for processing
+            response = await client.post(
+                "/v1/marketplace/sync",
+                json={"transactions": transactions}
+            )
+            response.raise_for_status()
+
+            logger.info(f"Successfully synced {len(transactions)} marketplace transactions")
+
+        except httpx.HTTPError as e:
+            logger.error(f"HTTP error syncing marketplace state: {e}")
+        except Exception as e:
+            logger.error(f"Error syncing marketplace state: {e}", exc_info=True)
+
+    # Phase 2: Contract event handlers
+    async def handle_contract_event(self, event_log: Dict[str, Any]) -> None:
+        """Handle AgentServiceMarketplace contract event."""
+        event_type = event_log.get("topics", [""])[0] if event_log.get("topics") else "Unknown"
+        logger.info(f"Handling marketplace contract event: {event_type}")
+
+        # Route based on event type
+        if "ServiceListed" in event_type:
+            await self._handle_service_listed(event_log)
+        elif "ServicePurchased" in event_type:
+            await self._handle_service_purchased(event_log)
+
+    async def _handle_service_listed(self, event_log: Dict[str, Any]) -> None:
+        """Handle ServiceListed event."""
+        try:
+            data = event_log.get("data", "{}")
+            logger.info(f"ServiceListed event: {data}")
+
+            # Call coordinator API to sync marketplace listing
+            logger.info("Would call coordinator API marketplace service to sync listing")
+
+        except Exception as e:
+            logger.error(f"Error handling ServiceListed event: {e}", exc_info=True)
+
+    async def _handle_service_purchased(self, event_log: Dict[str, Any]) -> None:
+        """Handle ServicePurchased event."""
+        try:
+            data = event_log.get("data", "{}")
+            logger.info(f"ServicePurchased event: {data}")
+
+            # Call coordinator API to sync marketplace purchase
+            logger.info("Would call coordinator API marketplace service to sync purchase")
+
+        except Exception as e:
+            logger.error(f"Error handling ServicePurchased event: {e}", exc_info=True)