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

tests/test_registrationIpfs.py

@@ -1,227 +0,0 @@
-"""
-Real Test for Agent Registration with IPFS Pin (using Pinata)
-Creates an agent, updates it on-chain, deletes it, reloads it, and verifies data integrity.
-"""
-
-import logging
-import time
-import random
-import sys
-
-# Configure logging: root logger at WARNING to suppress noisy dependencies
-logging.basicConfig(
-    level=logging.WARNING,
-    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
-    datefmt='%Y-%m-%d %H:%M:%S',
-    handlers=[logging.StreamHandler(sys.stdout)]
-)
-
-# Set debug level ONLY for agent0_sdk
-logging.getLogger('agent0_sdk').setLevel(logging.DEBUG)
-logging.getLogger('agent0_sdk.core').setLevel(logging.DEBUG)
-
-from agent0_sdk import SDK
-from config import CHAIN_ID, RPC_URL, AGENT_PRIVATE_KEY, PINATA_JWT, print_config
-
-
-def generateRandomData():
-    """Generate random test data for the agent."""
-    randomSuffix = random.randint(1000, 9999)
-    timestamp = int(time.time())
-    
-    return {
-        'name': f"Test Agent {randomSuffix}",
-        'description': f"Created at {timestamp}",
-        'image': f"https://example.com/image_{randomSuffix}.png",
-        'mcpEndpoint': f"https://api.example.com/mcp/{randomSuffix}",
-        'mcpVersion': f"2025-06-{random.randint(1, 28)}",
-        'a2aEndpoint': f"https://api.example.com/a2a/{randomSuffix}.json",
-        'a2aVersion': f"0.{random.randint(30, 35)}",
-        'ensName': f"test{randomSuffix}.eth",
-        'ensVersion': f"1.{random.randint(0, 9)}",
-        'walletAddress': f"0x{'a' * 40}",
-        'walletChainId': random.choice([1, 11155111, 8453, 137, 42161]),  # Mainnet, Sepolia, Base, Polygon, Arbitrum
-        'active': True,
-        'x402support': False,
-        'reputation': random.choice([True, False]),
-        'cryptoEconomic': random.choice([True, False]),
-        'teeAttestation': random.choice([True, False])
-    }
-
-
-def main():
-    print("🧪 Testing Agent Registration with IPFS Pin")
-    print_config()
-    
-    # SDK Configuration with Pinata IPFS
-    sdkConfig = {
-        'chainId': CHAIN_ID,
-        'rpcUrl': RPC_URL,
-        'ipfs': 'pinata',
-        'pinataJwt': PINATA_JWT
-    }
-    
-    sdk = SDK(signer=AGENT_PRIVATE_KEY, **sdkConfig)
-    testData = generateRandomData()
-    
-    agent = sdk.createAgent(
-        name=testData['name'],
-        description=testData['description'],
-        image=testData['image']
-    )
-    
-    agent.setMCP(testData['mcpEndpoint'], testData['mcpVersion'])
-    agent.setA2A(testData['a2aEndpoint'], testData['a2aVersion'])
-    agent.setENS(testData['ensName'], testData['ensVersion'])
-    agent.setAgentWallet(testData['walletAddress'], testData['walletChainId'])
-    agent.setActive(testData['active'])
-    agent.setX402Support(testData['x402support'])
-    agent.setTrust(
-        reputation=testData['reputation'],
-        cryptoEconomic=testData['cryptoEconomic'],
-        teeAttestation=testData['teeAttestation']
-    )
-    
-    print(f"\n✅ Created: {testData['name']}")
-    
-    agent.registerIPFS()
-    agentId = agent.agentId
-    print(f"✅ Registered: ID={agentId}")
-    
-    capturedState = {
-        'agentId': agent.agentId,
-        'agentURI': agent.agentURI,
-        'name': agent.name,
-        'description': agent.description,
-        'image': agent.image,
-        'walletAddress': agent.walletAddress,
-        'walletChainId': agent.walletChainId,
-        'active': agent.active,
-        'x402support': agent.x402support,
-        'mcpEndpoint': agent.mcpEndpoint,
-        'a2aEndpoint': agent.a2aEndpoint,
-        'ensEndpoint': agent.ensEndpoint,
-        'metadata': agent.metadata.copy()
-    }
-    
-    agent.updateInfo(
-        name=testData['name'] + " UPDATED",
-        description=testData['description'] + " - UPDATED",
-        image=f"https://example.com/image_{random.randint(1000, 9999)}_updated.png"
-    )
-    agent.setMCP(f"https://api.example.com/mcp/{random.randint(10000, 99999)}", f"2025-06-{random.randint(1, 28)}")
-    agent.setA2A(f"https://api.example.com/a2a/{random.randint(10000, 99999)}.json", f"0.{random.randint(30, 35)}")
-    agent.setAgentWallet(f"0x{'b' * 40}", random.choice([1, 11155111, 8453, 137, 42161]))
-    agent.setENS(f"{testData['ensName']}.updated", f"1.{random.randint(0, 9)}")
-    agent.setActive(False)
-    agent.setX402Support(True)
-    agent.setTrust(
-        reputation=random.choice([True, False]),
-        cryptoEconomic=random.choice([True, False]),
-        teeAttestation=random.choice([True, False])
-    )
-    agent.setMetadata({
-        "testKey": "testValue",
-        "timestamp": int(time.time()),
-        "customField": "customValue",
-        "anotherField": "anotherValue",
-        "numericField": random.randint(1000, 9999)
-    })
-    
-    agent.registerIPFS()
-    print(f"✅ Updated & re-registered")
-    
-    # Capture updated state before deletion
-    updatedState = {
-        'name': agent.name,
-        'description': agent.description,
-        'image': agent.image,
-        'walletAddress': agent.walletAddress,
-        'walletChainId': agent.walletChainId,
-        'active': agent.active,
-        'x402support': agent.x402support,
-        'mcpEndpoint': agent.mcpEndpoint,
-        'a2aEndpoint': agent.a2aEndpoint,
-        'ensEndpoint': agent.ensEndpoint,
-        'metadata': agent.metadata.copy()
-    }
-    
-    reloadedAgentId = agent.agentId
-    del agent
-    # Wait for blockchain transaction to be mined (Sepolia takes ~15 seconds)
-    print("⏳ Waiting for blockchain transaction to be mined (15 seconds)...")
-    time.sleep(15)
-    reloadedAgent = sdk.loadAgent(reloadedAgentId)
-    print(f"✅ Reloaded from blockchain")
-    
-    reloadedState = {
-        'name': reloadedAgent.name,
-        'description': reloadedAgent.description,
-        'image': reloadedAgent.image,
-        'walletAddress': reloadedAgent.walletAddress,
-        'walletChainId': reloadedAgent.walletChainId,
-        'active': reloadedAgent.active,
-        'x402support': reloadedAgent.x402support,
-        'mcpEndpoint': reloadedAgent.mcpEndpoint,
-        'a2aEndpoint': reloadedAgent.a2aEndpoint,
-        'ensEndpoint': reloadedAgent.ensEndpoint,
-        'metadata': reloadedAgent.metadata.copy()
-    }
-    
-    expectedState = updatedState
-    
-    # Override expected values for fields that should match the updated state
-    expectedState['walletAddress'] = f"0x{'b' * 40}"
-    # When wallet is set on-chain, walletChainId will be the current chain (where the update happened)
-    # This is different from the original registration file's chain ID
-    expectedState['walletChainId'] = sdk.chainId  # Current chain where wallet was updated
-    
-    allMatch = True
-    for field, expected in expectedState.items():
-        actual = reloadedState.get(field)
-        
-        # Handle type casting for metadata fields (on-chain values are strings)
-        if field == 'metadata' and isinstance(actual, dict) and isinstance(expected, dict):
-            # Try to cast string values back to their original types
-            normalized_actual = {}
-            for k, v in actual.items():
-                if k in expected:
-                    expected_val = expected[k]
-                    # If expected is int or float, try to cast
-                    if isinstance(expected_val, int):
-                        try:
-                            normalized_actual[k] = int(v) if isinstance(v, str) else v
-                        except (ValueError, TypeError):
-                            normalized_actual[k] = v
-                    elif isinstance(expected_val, float):
-                        try:
-                            normalized_actual[k] = float(v) if isinstance(v, str) else v
-                        except (ValueError, TypeError):
-                            normalized_actual[k] = v
-                    else:
-                        normalized_actual[k] = v
-                else:
-                    normalized_actual[k] = v
-            actual = normalized_actual
-        
-        if actual == expected:
-            print(f"✅ {field}: {actual}")
-        else:
-            print(f"❌ {field}: expected={expected}, got={actual}")
-            allMatch = False
-    
-    if allMatch:
-        print("\n✅ ALL CHECKS PASSED")
-    else:
-        print("\n❌ SOME CHECKS FAILED")
-
-
-if __name__ == "__main__":
-    try:
-        main()
-    except Exception as e:
-        print(f"\n❌ Error: {e}")
-        import traceback
-        traceback.print_exc()
-        exit(1)
-

tests/test_sdk.py

@@ -1,240 +0,0 @@
-"""
-Tests for SDK class.
-"""
-
-import pytest
-from unittest.mock import Mock, patch
-
-from agent0_sdk.core.sdk import SDK
-from agent0_sdk.core.models import EndpointType, TrustModel
-
-
-class TestSDK:
-    """Test SDK class."""
-    
-    def test_sdk_initialization(self):
-        """Test SDK initialization."""
-        with patch('agent0_sdk.core.sdk.Web3Client') as mock_web3:
-            mock_web3.return_value.chain_id = 11155111
-            
-            sdk = SDK(
-                chainId=11155111,
-                signer="0x1234567890abcdef",
-                rpcUrl="https://eth-sepolia.g.alchemy.com/v2/test"
-            )
-            
-            assert sdk.chainId == 11155111
-            assert sdk.rpcUrl == "https://eth-sepolia.g.alchemy.com/v2/test"
-            mock_web3.assert_called_once()
-    
-    def test_create_agent(self):
-        """Test agent creation."""
-        with patch('agent0_sdk.core.sdk.Web3Client') as mock_web3:
-            mock_web3.return_value.chain_id = 11155111
-            
-            sdk = SDK(
-                chainId=11155111,
-                signer="0x1234567890abcdef",
-                rpcUrl="https://eth-sepolia.g.alchemy.com/v2/test"
-            )
-            
-            agent = sdk.createAgent(
-                name="Test Agent",
-                description="A test agent",
-                image="https://example.com/image.png"
-            )
-            
-            assert agent.name == "Test Agent"
-            assert agent.description == "A test agent"
-            assert agent.image == "https://example.com/image.png"
-            assert agent.sdk == sdk
-    
-    def test_registries(self):
-        """Test registry resolution."""
-        with patch('agent0_sdk.core.sdk.Web3Client') as mock_web3:
-            mock_web3.return_value.chain_id = 11155111
-            
-            sdk = SDK(
-                chainId=11155111,
-                signer="0x1234567890abcdef",
-                rpcUrl="https://eth-sepolia.g.alchemy.com/v2/test"
-            )
-            
-        registries = sdk.registries()
-        assert "IDENTITY" in registries
-        assert "REPUTATION" in registries
-        assert "VALIDATION" in registries
-    
-    def test_set_chain(self):
-        """Test chain switching."""
-        with patch('agent0_sdk.core.sdk.Web3Client') as mock_web3:
-            mock_web3.return_value.chain_id = 11155111
-            
-            sdk = SDK(
-                chainId=11155111,
-                signer="0x1234567890abcdef",
-                rpcUrl="https://eth-sepolia.g.alchemy.com/v2/test"
-            )
-            
-            sdk.set_chain(84532)  # Switch to Base Sepolia
-            assert sdk.chainId == 84532
-            assert sdk._registries["IDENTITY"] is not None  # Should have Base Sepolia registry
-
-
-class TestAgent:
-    """Test Agent class."""
-    
-    def test_agent_endpoint_management(self):
-        """Test agent endpoint management."""
-        with patch('agent0_sdk.core.sdk.Web3Client') as mock_web3:
-            mock_web3.return_value.chain_id = 11155111
-            
-            sdk = SDK(
-                chainId=11155111,
-                signer="0x1234567890abcdef",
-                rpcUrl="https://eth-sepolia.g.alchemy.com/v2/test"
-            )
-            
-            agent = sdk.createAgent("Test Agent", "A test agent")
-            
-            # Add MCP endpoint
-            agent.setMCP("https://mcp.example.com/")
-            assert len(agent.endpoints) == 1
-            assert agent.endpoints[0].type == EndpointType.MCP
-            assert agent.endpoints[0].value == "https://mcp.example.com/"
-            assert agent.endpoints[0].meta["version"] == "2025-06-18"
-            
-            # Add A2A endpoint
-            agent.setA2A("https://a2a.example.com/", "1.0")
-            assert len(agent.endpoints) == 2
-            
-            # Add ENS endpoint
-            agent.setENS("test-agent.eth")
-            assert len(agent.endpoints) == 3
-            ens_endpoint = next(ep for ep in agent.endpoints if ep.type == EndpointType.ENS)
-            assert ens_endpoint.value == "test-agent.eth"
-            assert ens_endpoint.meta["version"] == "1.0"
-            
-            # Remove specific endpoint
-            agent.removeEndpoint(EndpointType.MCP, "https://mcp.example.com/")
-            assert len(agent.endpoints) == 2
-            assert agent.endpoints[0].type == EndpointType.A2A
-            
-            # Remove all endpoints
-            agent.removeEndpoints()
-            assert len(agent.endpoints) == 0
-    
-    def test_agent_trust_models(self):
-        """Test agent trust model management."""
-        with patch('agent0_sdk.core.sdk.Web3Client') as mock_web3:
-            mock_web3.return_value.chain_id = 11155111
-            
-            sdk = SDK(
-                chainId=11155111,
-                signer="0x1234567890abcdef",
-                rpcUrl="https://eth-sepolia.g.alchemy.com/v2/test"
-            )
-            
-            agent = sdk.createAgent("Test Agent", "A test agent")
-            
-            # Set trust models using new method
-            agent.setTrust(reputation=True, cryptoEconomic=True)
-            # Access trustModels through registration_file since property is shadowed by method
-            assert len(agent.registration_file.trustModels) == 2
-            assert TrustModel.REPUTATION in agent.registration_file.trustModels
-            assert TrustModel.CRYPTO_ECONOMIC in agent.registration_file.trustModels
-            
-            # Set trust models using direct assignment (since trustModels is a property, not callable)
-            agent.registration_file.trustModels = [TrustModel.REPUTATION, "custom_trust"]
-            assert len(agent.registration_file.trustModels) == 2
-            assert TrustModel.REPUTATION in agent.registration_file.trustModels
-            assert "custom_trust" in agent.registration_file.trustModels
-    
-    def test_agent_metadata_management(self):
-        """Test agent metadata management."""
-        with patch('agent0_sdk.core.sdk.Web3Client') as mock_web3:
-            mock_web3.return_value.chain_id = 11155111
-            
-            sdk = SDK(
-                chainId=11155111,
-                signer="0x1234567890abcdef",
-                rpcUrl="https://eth-sepolia.g.alchemy.com/v2/test"
-            )
-            
-            agent = sdk.createAgent("Test Agent", "A test agent")
-            
-            # Set metadata
-            agent.setMetadata({"key1": "value1", "key2": "value2"})
-            assert agent.getMetadata() == {"key1": "value1", "key2": "value2"}
-            
-            # Set single key using setMetadata
-            agent.setMetadata({"key3": "value3"})
-            assert agent.getMetadata() == {"key1": "value1", "key2": "value2", "key3": "value3"}
-            
-            # Delete key
-            agent.delMetadata("key2")
-            assert agent.getMetadata() == {"key1": "value1", "key3": "value3"}
-    
-    def test_agent_info_update(self):
-        """Test agent info updates."""
-        with patch('agent0_sdk.core.sdk.Web3Client') as mock_web3:
-            mock_web3.return_value.chain_id = 11155111
-            
-            sdk = SDK(
-                chainId=11155111,
-                signer="0x1234567890abcdef",
-                rpcUrl="https://eth-sepolia.g.alchemy.com/v2/test"
-            )
-            
-            agent = sdk.createAgent("Test Agent", "A test agent")
-            
-            # Update info
-            agent.updateInfo(
-                name="Updated Agent",
-                description="An updated agent",
-                image="https://example.com/new-image.png"
-            )
-            
-            assert agent.name == "Updated Agent"
-            assert agent.description == "An updated agent"
-            assert agent.image == "https://example.com/new-image.png"
-            
-            # Set wallet address (must be valid 42-character Ethereum address)
-            valid_address = "0x1234567890abcdef1234567890abcdef12345678"
-            agent.setAgentWallet(valid_address)
-            assert agent.walletAddress == valid_address
-    
-    def test_agent_json_serialization(self):
-        """Test agent JSON serialization."""
-        with patch('agent0_sdk.core.sdk.Web3Client') as mock_web3:
-            mock_web3.return_value.chain_id = 11155111
-            
-            sdk = SDK(
-                chainId=11155111,
-                signer="0x1234567890abcdef",
-                rpcUrl="https://eth-sepolia.g.alchemy.com/v2/test"
-            )
-            
-            agent = sdk.createAgent("Test Agent", "A test agent")
-            agent.setMCP("https://mcp.example.com/")
-            agent.setTrust(reputation=True)
-            
-            json_data = agent.toJson()
-            assert isinstance(json_data, str)
-            assert "Test Agent" in json_data
-            assert "MCP" in json_data
-            assert "reputation" in json_data
-            
-            # Test x402 support
-            agent.setX402Support(True)
-            assert agent.x402support is True
-            
-            json_data_with_x402 = agent.toJson()
-            assert "x402support" in json_data_with_x402
-            
-            # Test active status
-            agent.setActive(True)
-            assert agent.active is True
-            
-            agent.setActive(False)
-            assert agent.active is False