agent0-sdk 0.2.2__py3-none-any.whl → 0.5__py3-none-any.whl

agent0_sdk/core/subgraph_client.py

@@ -30,25 +30,38 @@ class SubgraphClient:
         Returns:
             JSON response from the subgraph
         """
-        try:
+        def _do_query(q: str) -> Dict[str, Any]:
             response = requests.post(
                 self.subgraph_url,
-                json={
-                    'query': query,
-                    'variables': variables or {}
-                },
+                json={'query': q, 'variables': variables or {}},
                 headers={'Content-Type': 'application/json'},
-                timeout=30
+                timeout=10,
             )
             response.raise_for_status()
             result = response.json()
-            
-            # Check for GraphQL errors
             if 'errors' in result:
                 error_messages = [err.get('message', 'Unknown error') for err in result['errors']]
                 raise ValueError(f"GraphQL errors: {', '.join(error_messages)}")
-            
             return result.get('data', {})
+
+        try:
+            return _do_query(query)
+        except ValueError as e:
+            # Backwards/forwards compatibility for hosted subgraphs:
+            # Some deployments still expose `responseUri` instead of `responseURI`.
+            msg = str(e)
+            if ("has no field" in msg and "responseURI" in msg) and ("responseURI" in query):
+                logger.debug("Subgraph schema missing responseURI; retrying query with responseUri")
+                return _do_query(query.replace("responseURI", "responseUri"))
+            # Some deployments don't expose agentWallet fields on AgentRegistrationFile.
+            if (
+                "Type `AgentRegistrationFile` has no field `agentWallet`" in msg
+                or "Type `AgentRegistrationFile` has no field `agentWalletChainId`" in msg
+            ):
+                logger.debug("Subgraph schema missing agentWallet fields; retrying query without them")
+                q2 = query.replace("agentWalletChainId", "").replace("agentWallet", "")
+                return _do_query(q2)
+            raise
         except requests.exceptions.RequestException as e:
             raise ConnectionError(f"Failed to query subgraph: {e}")
 
@@ -248,10 +261,12 @@ class SubgraphClient:
                 ) {{
                     id
                     score
+                    feedbackIndex
                     tag1
                     tag2
+                    endpoint
                     clientAddress
-                    feedbackUri
+                    feedbackURI
                     feedbackURIType
                     feedbackHash
                     isRevoked
@@ -276,7 +291,7 @@ class SubgraphClient:
                     responses {{
                         id
                         responder
-                        responseUri
+                        responseURI
                         responseHash
                         createdAt
                     }}
@@ -400,10 +415,12 @@ class SubgraphClient:
                 id
                 agent { id agentId chainId }
                 clientAddress
+                feedbackIndex
                 score
                 tag1
                 tag2
-                feedbackUri
+                endpoint
+                feedbackURI
                 feedbackURIType
                 feedbackHash
                 isRevoked
@@ -429,7 +446,7 @@ class SubgraphClient:
                 responses {
                     id
                     responder
-                    responseUri
+                    responseURI
                     responseHash
                     createdAt
                 }
@@ -548,10 +565,12 @@ class SubgraphClient:
                 id
                 agent {{ id agentId chainId }}
                 clientAddress
+                feedbackIndex
                 score
                 tag1
                 tag2
-                feedbackUri
+                endpoint
+                feedbackURI
                 feedbackURIType
                 feedbackHash
                 isRevoked
@@ -577,7 +596,7 @@ class SubgraphClient:
                 responses {{
                     id
                     responder
-                    responseUri
+                    responseURI
                     responseHash
                     createdAt
                 }}
@@ -716,12 +735,14 @@ class SubgraphClient:
                 return []
         else:
             # No feedback filters - query agents directly
-            agent_filters = []
+            # For reputation search, we want agents that have feedback
+            # Filter by totalFeedback > 0 to only get agents with feedback
+            agent_filters = ['totalFeedback_gt: 0']  # Only agents with feedback (BigInt comparison)
             if agents is not None and len(agents) > 0:
                 agent_ids = [f'"{aid}"' for aid in agents]
                 agent_filters.append(f'id_in: [{", ".join(agent_ids)}]')
             
-            agent_where = f"where: {{ {', '.join(agent_filters)} }}" if agent_filters else ""
+            agent_where = f"where: {{ {', '.join(agent_filters)} }}"
         
         # Build feedback where for agent query (to calculate scores)
         feedback_where_for_agents = f"{{ {', '.join(feedback_filters)} }}" if feedback_filters else "{}"
@@ -784,6 +805,12 @@ class SubgraphClient:
         
         try:
             result = self.query(query)
+            
+            # Check for GraphQL errors
+            if 'errors' in result:
+                logger.error(f"GraphQL errors in search_agents_by_reputation: {result['errors']}")
+                return []
+            
             agents_result = result.get('agents', [])
             
             # Calculate average scores
@@ -806,6 +833,18 @@ class SubgraphClient:
                     if agent.get('averageScore') is not None and agent['averageScore'] >= minAverageScore
                 ]
             
+            # For reputation search, filter logic:
+            # - If specific agents were requested, return them even if averageScore is None
+            #   (the user explicitly asked for these agents, so return them)
+            # - If general search (no specific agents), only return agents with reputation data
+            if agents is None or len(agents) == 0:
+                # General search - only return agents with reputation
+                agents_result = [
+                    agent for agent in agents_result
+                    if agent.get('averageScore') is not None
+                ]
+            # else: specific agents requested - return all requested agents (even if averageScore is None)
+            
             return agents_result
             
         except Exception as e:

agent0_sdk/core/web3_client.py

@@ -5,7 +5,7 @@ Web3 integration layer for smart contract interactions.
 from __future__ import annotations
 
 import json
-from typing import Any, Dict, List, Optional, Tuple, Union
+from typing import Any, Dict, List, Optional, Tuple, Union, Callable
 
 try:
     from web3 import Web3
@@ -123,22 +123,6 @@ class Web3Client:
         
         return event_filter.get_all_entries()
 
-    def encodeFeedbackAuth(
-        self,
-        agentId: int,
-        clientAddress: str,
-        indexLimit: int,
-        expiry: int,
-        chainId: int,
-        identityRegistry: str,
-        signerAddress: str
-    ) -> bytes:
-        """Encode feedback authorization data."""
-        return self.w3.codec.encode(
-            ['uint256', 'address', 'uint64', 'uint256', 'uint256', 'address', 'address'],
-            [agentId, clientAddress, indexLimit, expiry, chainId, identityRegistry, signerAddress]
-        )
-
     def signMessage(self, message: bytes) -> bytes:
         """Sign a message with the account's private key."""
         # Create a SignableMessage from the raw bytes
@@ -190,3 +174,186 @@ class Web3Client:
     def get_transaction_count(self, address: str) -> int:
         """Get transaction count (nonce) of an address."""
         return self.w3.eth.get_transaction_count(address)
+
+    def encodeEIP712Domain(
+        self,
+        name: str,
+        version: str,
+        chain_id: int,
+        verifying_contract: str
+    ) -> Dict[str, Any]:
+        """Encode EIP-712 domain separator.
+        
+        Args:
+            name: Contract name
+            version: Contract version
+            chain_id: Chain ID
+            verifying_contract: Contract address
+            
+        Returns:
+            Domain separator dictionary
+        """
+        return {
+            "name": name,
+            "version": version,
+            "chainId": chain_id,
+            "verifyingContract": verifying_contract
+        }
+
+    def build_agent_wallet_set_typed_data(
+        self,
+        agent_id: int,
+        new_wallet: str,
+        owner: str,
+        deadline: int,
+        verifying_contract: str,
+        chain_id: int,
+    ) -> Dict[str, Any]:
+        """Build EIP-712 typed data for ERC-8004 IdentityRegistry setAgentWallet.
+
+        Contract expects:
+        - domain: name="ERC8004IdentityRegistry", version="1"
+        - primaryType: "AgentWalletSet"
+        - message: { agentId, newWallet, owner, deadline }
+        """
+        domain = self.encodeEIP712Domain(
+            name="ERC8004IdentityRegistry",
+            version="1",
+            chain_id=chain_id,
+            verifying_contract=verifying_contract,
+        )
+
+        message_types = {
+            "AgentWalletSet": [
+                {"name": "agentId", "type": "uint256"},
+                {"name": "newWallet", "type": "address"},
+                {"name": "owner", "type": "address"},
+                {"name": "deadline", "type": "uint256"},
+            ]
+        }
+
+        message = {
+            "agentId": agent_id,
+            "newWallet": new_wallet,
+            "owner": owner,
+            "deadline": deadline,
+        }
+
+        # eth_account.messages.encode_typed_data expects the "full_message" format
+        return {
+            "types": {
+                "EIP712Domain": [
+                    {"name": "name", "type": "string"},
+                    {"name": "version", "type": "string"},
+                    {"name": "chainId", "type": "uint256"},
+                    {"name": "verifyingContract", "type": "address"},
+                ],
+                **message_types,
+            },
+            "domain": domain,
+            "primaryType": "AgentWalletSet",
+            "message": message,
+        }
+
+    def sign_typed_data(
+        self,
+        full_message: Dict[str, Any],
+        signer: Union[str, BaseAccount],
+    ) -> bytes:
+        """Sign EIP-712 typed data with a provided signer (EOA).
+
+        Args:
+            full_message: Typed data dict compatible with encode_typed_data(full_message=...)
+            signer: Private key string or eth_account BaseAccount/LocalAccount
+
+        Returns:
+            Signature bytes
+        """
+        from eth_account.messages import encode_typed_data
+
+        if isinstance(signer, str):
+            acct: BaseAccount = Account.from_key(signer)
+        else:
+            acct = signer
+
+        encoded = encode_typed_data(full_message=full_message)
+        signed = acct.sign_message(encoded)
+        return signed.signature
+
+    def signEIP712Message(
+        self,
+        domain: Dict[str, Any],
+        message_types: Dict[str, List[Dict[str, str]]],
+        message: Dict[str, Any]
+    ) -> bytes:
+        """Sign an EIP-712 typed message.
+        
+        Args:
+            domain: EIP-712 domain separator
+            message_types: Type definitions for the message
+            message: Message data to sign
+            
+        Returns:
+            Signature bytes
+        """
+        if not self.account:
+            raise ValueError("Cannot sign message: SDK is in read-only mode. Provide a signer to enable signing.")
+        
+        from eth_account.messages import encode_typed_data
+        
+        structured_data = {
+            "types": {
+                "EIP712Domain": [
+                    {"name": "name", "type": "string"},
+                    {"name": "version", "type": "string"},
+                    {"name": "chainId", "type": "uint256"},
+                    {"name": "verifyingContract", "type": "address"}
+                ],
+                **message_types
+            },
+            "domain": domain,
+            "primaryType": list(message_types.keys())[0] if message_types else "Message",
+            "message": message
+        }
+        
+        encoded = encode_typed_data(full_message=structured_data)
+        signed = self.account.sign_message(encoded)
+        return signed.signature
+
+    def verifyEIP712Signature(
+        self,
+        domain: Dict[str, Any],
+        message_types: Dict[str, List[Dict[str, str]]],
+        message: Dict[str, Any],
+        signature: bytes
+    ) -> str:
+        """Verify an EIP-712 signature and recover the signer address.
+        
+        Args:
+            domain: EIP-712 domain separator
+            message_types: Type definitions for the message
+            message: Message data that was signed
+            signature: Signature bytes to verify
+            
+        Returns:
+            Recovered signer address
+        """
+        from eth_account.messages import encode_typed_data
+        
+        structured_data = {
+            "types": {
+                "EIP712Domain": [
+                    {"name": "name", "type": "string"},
+                    {"name": "version", "type": "string"},
+                    {"name": "chainId", "type": "uint256"},
+                    {"name": "verifyingContract", "type": "address"}
+                ],
+                **message_types
+            },
+            "domain": domain,
+            "primaryType": list(message_types.keys())[0] if message_types else "Message",
+            "message": message
+        }
+        
+        encoded = encode_typed_data(full_message=structured_data)
+        return self.w3.eth.account.recover_message(encoded, signature=signature)