traia-iatp 0.1.29__py3-none-any.whl

traia_iatp/contracts/iatp_contracts_config.py

@@ -0,0 +1,263 @@
+"""Contract configuration and utilities for IATP.
+
+This module provides centralized contract configuration management for all IATP packages.
+It loads contract addresses and ABIs from the iatp-contracts deployment artifacts.
+"""
+
+import json
+import os
+from enum import Enum
+from pathlib import Path
+from typing import Dict, List, Optional
+
+from web3 import Web3
+
+# Contract types
+class ContractName(str, Enum):
+    """Supported contract names."""
+    IATP_WALLET = "IATPWallet"
+    IATP_WALLET_FACTORY = "IATPWalletFactory"
+    IATP_SETTLEMENT_LAYER = "IATPSettlementLayer"
+    ROLE_MANAGER = "RoleManager"
+
+
+# Supported networks
+SUPPORTED_NETWORKS = ["sepolia", "base-sepolia", "arbitrum-sepolia", "localhost"]
+
+# Default RPC URLs
+DEFAULT_RPC_URLS = {
+    "sepolia": "https://ethereum-sepolia-rpc.publicnode.com",
+    "base-sepolia": "https://sepolia.base.org",
+    "arbitrum-sepolia": "https://sepolia-rollup.arbitrum.io/rpc",
+    "localhost": "http://127.0.0.1:8545"
+}
+
+# Cache for loaded data
+_contract_addresses_cache: Dict[str, Dict] = {}
+_contract_abis_cache: Dict[str, Dict] = {}
+
+
+def _get_contracts_dir() -> Path:
+    """Get the contracts directory path.
+    
+    Uses the package's data directory where ABIs and addresses are copied.
+    This directory should be updated manually whenever contracts are redeployed.
+    
+    Location: IATP/src/traia_iatp/contracts/data/
+    """
+    # Use the data directory in the package
+    data_dir = Path(__file__).parent / "data"
+    
+    # Verify it exists and has required subdirectories
+    abis_dir = data_dir / "abis"
+    addresses_dir = data_dir / "addresses"
+    
+    if not data_dir.exists():
+        raise FileNotFoundError(
+            f"Contracts data directory not found: {data_dir}\n"
+            "Please ensure contract ABIs and addresses are copied to this location."
+        )
+    
+    if not abis_dir.exists() or not addresses_dir.exists():
+        raise FileNotFoundError(
+            f"Contract ABIs or addresses directory missing in {data_dir}\n"
+            "Expected structure:\n"
+            "  data/abis/contract-abis-*.json\n"
+            "  data/addresses/contract-*.json"
+        )
+    
+    # Verify files exist
+    if not list(abis_dir.glob("*.json")):
+        raise FileNotFoundError(f"No ABI files found in {abis_dir}")
+    
+    if not list(addresses_dir.glob("*.json")):
+        raise FileNotFoundError(f"No address files found in {addresses_dir}")
+    
+    return data_dir
+
+
+def get_contract_address(contract_name: str, network: str = "sepolia") -> Optional[str]:
+    """Get contract address for a given network.
+    
+    Args:
+        contract_name: Name of the contract (e.g., "IATPWallet")
+        network: Network name (default: "sepolia")
+        
+    Returns:
+        Contract address as hex string, or None if not found
+    """
+    if network not in SUPPORTED_NETWORKS:
+        raise ValueError(f"Unsupported network: {network}. Supported: {SUPPORTED_NETWORKS}")
+    
+    # Check cache
+    cache_key = f"{network}:addresses"
+    if cache_key not in _contract_addresses_cache:
+        # Load addresses file
+        contracts_dir = _get_contracts_dir()
+        
+        # Get addresses directory (no symlinks - direct files)
+        addresses_dir = contracts_dir / "addresses"
+        
+        if network == "localhost":
+            addresses_file = addresses_dir / "contract-addresses.json"
+        else:
+            addresses_file = addresses_dir / f"contract-proxies-{network}.json"
+        
+        if not addresses_file.exists():
+            # Try without network suffix
+            addresses_file = addresses_dir / "contract-proxies.json"
+        
+        if not addresses_file.exists():
+            return None
+        
+        with open(addresses_file, 'r') as f:
+            data = json.load(f)
+            
+            # Handle nested structure: {network: {contract: address}}
+            if network in data:
+                _contract_addresses_cache[cache_key] = data[network]
+            else:
+                # Flat structure: {contract: address}
+                _contract_addresses_cache[cache_key] = data
+    
+    addresses = _contract_addresses_cache[cache_key]
+    return addresses.get(contract_name)
+
+
+def get_contract_abi(contract_name: str, network: str = "sepolia") -> Optional[List[dict]]:
+    """Get contract ABI for a given network.
+    
+    Args:
+        contract_name: Name of the contract (e.g., "IATPWallet")
+        network: Network name (default: "sepolia")
+        
+    Returns:
+        Contract ABI as list of dicts, or None if not found
+    """
+    if network not in SUPPORTED_NETWORKS:
+        raise ValueError(f"Unsupported network: {network}. Supported: {SUPPORTED_NETWORKS}")
+    
+    # Check cache
+    cache_key = f"{network}:abis"
+    if cache_key not in _contract_abis_cache:
+        # Load ABIs file
+        contracts_dir = _get_contracts_dir()
+        
+        # Get ABIs directory (no symlinks - direct files)
+        abis_dir = contracts_dir / "abis"
+        
+        abis_file = abis_dir / f"contract-abis-{network}.json"
+        
+        if not abis_file.exists():
+            return None
+        
+        with open(abis_file, 'r') as f:
+            data = json.load(f)
+            
+            # Handle nested structure: {network: {contract: [abi]}}
+            if network in data:
+                # Data is nested by network
+                _contract_abis_cache[cache_key] = data[network]
+            else:
+                # Flat structure: {contract: {abi: [...]}} or {contract: [abi]}
+                _contract_abis_cache[cache_key] = data
+    
+    abis = _contract_abis_cache[cache_key]
+    
+    # Handle different ABI structures
+    contract_data = abis.get(contract_name)
+    if isinstance(contract_data, list):
+        # Direct ABI list: {contract: [abi]}
+        return contract_data
+    elif isinstance(contract_data, dict) and "abi" in contract_data:
+        # Wrapped ABI: {contract: {abi: [...]}}
+        return contract_data.get("abi")
+    else:
+        return None
+
+
+def get_rpc_url(network: str = "sepolia") -> str:
+    """Get RPC URL for a network.
+    
+    First checks environment variables, then falls back to defaults.
+    
+    Environment variables:
+    - SEPOLIA_RPC_URL
+    - BASE_SEPOLIA_RPC_URL
+    - ARBITRUM_SEPOLIA_RPC_URL
+    - LOCALHOST_RPC_URL
+    
+    Args:
+        network: Network name (default: "sepolia")
+        
+    Returns:
+        RPC URL as string
+    """
+    if network not in SUPPORTED_NETWORKS:
+        raise ValueError(f"Unsupported network: {network}. Supported: {SUPPORTED_NETWORKS}")
+    
+    # Check environment variable
+    env_var = f"{network.upper().replace('-', '_')}_RPC_URL"
+    rpc_url = os.getenv(env_var)
+    
+    if rpc_url:
+        return rpc_url
+    
+    # Fall back to default
+    return DEFAULT_RPC_URLS.get(network, DEFAULT_RPC_URLS["sepolia"])
+
+
+def get_web3_provider(network: str = "sepolia") -> Web3:
+    """Get Web3 provider for a network.
+    
+    Args:
+        network: Network name (default: "sepolia")
+        
+    Returns:
+        Web3 instance connected to the network
+    """
+    rpc_url = get_rpc_url(network)
+    w3 = Web3(Web3.HTTPProvider(rpc_url))
+    
+    if not w3.is_connected():
+        raise ConnectionError(f"Failed to connect to {network} at {rpc_url}")
+    
+    return w3
+
+
+def load_contract(
+    contract_name: str,
+    network: str = "sepolia",
+    address: Optional[str] = None
+):
+    """Load a contract instance with Web3.
+    
+    Args:
+        contract_name: Name of the contract
+        network: Network name (default: "sepolia")
+        address: Optional contract address (uses deployed address if not provided)
+        
+    Returns:
+        Web3 contract instance
+    """
+    w3 = get_web3_provider(network)
+    
+    # Get ABI
+    abi = get_contract_abi(contract_name, network)
+    if not abi:
+        raise ValueError(f"ABI not found for {contract_name} on {network}")
+    
+    # Get address
+    if not address:
+        address = get_contract_address(contract_name, network)
+        if not address:
+            raise ValueError(f"Address not found for {contract_name} on {network}")
+    
+    # Create contract instance
+    contract = w3.eth.contract(
+        address=Web3.to_checksum_address(address),
+        abi=abi
+    )
+    
+    return contract, w3
+

traia_iatp/contracts/wallet_creator.py

@@ -0,0 +1,255 @@
+"""IATPWallet creation script using IATPWalletFactory.
+
+This script creates a new IATPWallet by calling the IATPWalletFactory contract.
+It generates an operator keypair and deploys a wallet for a given owner.
+
+Uses centralized contract configuration from traia_iatp.contracts.config.
+"""
+
+import os
+import json
+from typing import Dict, Optional, Tuple
+from pathlib import Path
+from eth_account import Account
+from web3 import Web3
+from web3.contract import Contract
+
+
+def get_contract_config(network: str = "sepolia") -> Dict:
+    """Load contract addresses and ABIs for a network.
+    
+    Uses the centralized config module from traia_iatp.contracts.config.
+    
+    Args:
+        network: Network name (sepolia, base-sepolia, etc.)
+        
+    Returns:
+        Dict with addresses and ABIs
+    """
+    from traia_iatp.contracts.iatp_contracts_config import get_contract_address, get_contract_abi
+    
+    # Get all contract addresses and ABIs
+    contract_names = ["IATPWalletFactory", "IATPSettlementLayer", "IATPWallet", "RoleManager"]
+    addresses = {}
+    abis = {}
+    
+    for name in contract_names:
+        try:
+            address = get_contract_address(name, network)
+            if address:
+                addresses[name] = address
+            
+            abi = get_contract_abi(name, network)
+            if abi:
+                abis[name] = {"abi": abi}
+        except Exception as e:
+            # Some contracts may not be on all networks
+            pass
+    
+    return {
+        "addresses": addresses,
+        "abis": abis
+    }
+
+
+def create_wallet(
+    owner_private_key: str,
+    network: str = "sepolia",
+    rpc_url: Optional[str] = None,
+    maintainer_private_key: Optional[str] = None
+) -> Tuple[str, str, str]:
+    """Create a new IATPWallet using IATPWalletFactory.
+    
+    Args:
+        owner_private_key: Private key of the wallet owner
+        network: Network name (default: sepolia)
+        rpc_url: Optional RPC URL (uses default if not provided)
+        maintainer_private_key: Optional maintainer key (if calling createWalletFor)
+        
+    Returns:
+        Tuple of (wallet_address, operator_address, operator_private_key)
+    """
+    # Setup Web3
+    if not rpc_url:
+        rpc_urls = {
+            "sepolia": os.getenv("SEPOLIA_RPC_URL", "https://ethereum-sepolia-rpc.publicnode.com"),
+            "base-sepolia": os.getenv("BASE_SEPOLIA_RPC_URL", "https://sepolia.base.org"),
+            "arbitrum-sepolia": os.getenv("ARBITRUM_SEPOLIA_RPC_URL", "https://sepolia-rollup.arbitrum.io/rpc"),
+        }
+        rpc_url = rpc_urls.get(network)
+    
+    w3 = Web3(Web3.HTTPProvider(rpc_url))
+    
+    if not w3.is_connected():
+        raise ConnectionError(f"Could not connect to {network} at {rpc_url}")
+    
+    print(f"✅ Connected to {network}")
+    print(f"   RPC: {rpc_url}")
+    print(f"   Chain ID: {w3.eth.chain_id}")
+    
+    # Load contract config
+    config = get_contract_config(network)
+    factory_address = config["addresses"].get("IATPWalletFactory")
+    factory_abi = config["abis"].get("IATPWalletFactory", {}).get("abi")
+    
+    if not factory_address:
+        raise ValueError(f"IATPWalletFactory address not found for {network}")
+    
+    if not factory_abi:
+        raise ValueError(f"IATPWalletFactory ABI not found for {network}")
+    
+    print(f"\n📝 Contract Configuration:")
+    print(f"   Factory: {factory_address}")
+    
+    # Create owner account
+    if owner_private_key.startswith("0x"):
+        owner_private_key = owner_private_key[2:]
+    owner_account = Account.from_key(owner_private_key)
+    print(f"\n👤 Owner Account: {owner_account.address}")
+    
+    # Check owner balance
+    owner_balance = w3.eth.get_balance(owner_account.address)
+    print(f"   Balance: {w3.from_wei(owner_balance, 'ether')} ETH")
+    
+    if owner_balance == 0:
+        print(f"   ⚠️  Warning: Owner has no ETH for gas")
+    
+    # Generate operator keypair
+    operator_account = Account.create()
+    operator_address = operator_account.address
+    operator_private_key = operator_account.key.hex()
+    
+    print(f"\n🔑 Generated Operator:")
+    print(f"   Address: {operator_address}")
+    print(f"   Private Key: {operator_private_key}")
+    
+    # Create factory contract instance
+    factory_contract = w3.eth.contract(
+        address=Web3.to_checksum_address(factory_address),
+        abi=factory_abi
+    )
+    
+    # Determine which method to call
+    if maintainer_private_key:
+        # Use createWalletFor (maintainer only)
+        if maintainer_private_key.startswith("0x"):
+            maintainer_private_key = maintainer_private_key[2:]
+        caller_account = Account.from_key(maintainer_private_key)
+        
+        print(f"\n📞 Calling createWalletFor() as maintainer")
+        print(f"   Maintainer: {caller_account.address}")
+        
+        # Build transaction
+        tx = factory_contract.functions.createWalletFor(
+            owner_account.address,
+            operator_address
+        ).build_transaction({
+            'from': caller_account.address,
+            'nonce': w3.eth.get_transaction_count(caller_account.address),
+            'gas': 2000000,
+            'gasPrice': w3.eth.gas_price,
+            'chainId': w3.eth.chain_id
+        })
+        
+        # Sign and send
+        signed_tx = w3.eth.account.sign_transaction(tx, maintainer_private_key)
+    else:
+        # Use createWallet (owner calls)
+        print(f"\n📞 Calling createWallet() as owner")
+        
+        # Build transaction
+        tx = factory_contract.functions.createWallet(
+            operator_address
+        ).build_transaction({
+            'from': owner_account.address,
+            'nonce': w3.eth.get_transaction_count(owner_account.address),
+            'gas': 2000000,
+            'gasPrice': w3.eth.gas_price,
+            'chainId': w3.eth.chain_id
+        })
+        
+        # Sign and send
+        signed_tx = w3.eth.account.sign_transaction(tx, owner_private_key)
+    
+    print(f"\n🚀 Sending transaction...")
+    tx_hash = w3.eth.send_raw_transaction(signed_tx.raw_transaction)
+    print(f"   TX Hash: {tx_hash.hex()}")
+    
+    print(f"\n⏳ Waiting for confirmation...")
+    tx_receipt = w3.eth.wait_for_transaction_receipt(tx_hash, timeout=120)
+    
+    if tx_receipt['status'] == 1:
+        print(f"✅ Transaction confirmed!")
+        print(f"   Block: {tx_receipt['blockNumber']}")
+        print(f"   Gas Used: {tx_receipt['gasUsed']}")
+        
+        # Parse logs to get wallet address
+        wallet_created_event = factory_contract.events.WalletCreated()
+        logs = wallet_created_event.process_receipt(tx_receipt)
+        
+        if logs:
+            wallet_address = logs[0]['args']['wallet']
+            print(f"\n🎉 Wallet Created!")
+            print(f"   Wallet Address: {wallet_address}")
+            print(f"   Owner: {logs[0]['args']['owner']}")
+            print(f"   Operator: {logs[0]['args']['operatorAddress']}")
+            
+            return wallet_address, operator_address, operator_private_key
+        else:
+            raise Exception("WalletCreated event not found in logs")
+    else:
+        raise Exception(f"Transaction failed: {tx_receipt}")
+
+
+def main():
+    """CLI entry point for wallet creation."""
+    import argparse
+    
+    parser = argparse.ArgumentParser(description="Create IATPWallet using IATPWalletFactory")
+    parser.add_argument("--owner-key", required=True, help="Owner's private key")
+    parser.add_argument("--network", default="sepolia", help="Network name (default: sepolia)")
+    parser.add_argument("--rpc-url", help="Custom RPC URL")
+    parser.add_argument("--maintainer-key", help="Maintainer key (for createWalletFor)")
+    parser.add_argument("--output", help="Output file for wallet info (JSON)")
+    
+    args = parser.parse_args()
+    
+    try:
+        wallet_address, operator_address, operator_private_key = create_wallet(
+            owner_private_key=args.owner_key,
+            network=args.network,
+            rpc_url=args.rpc_url,
+            maintainer_private_key=args.maintainer_key
+        )
+        
+        result = {
+            "wallet_address": wallet_address,
+            "operator_address": operator_address,
+            "operator_private_key": operator_private_key,
+            "owner_address": Account.from_key(args.owner_key).address,
+            "network": args.network
+        }
+        
+        if args.output:
+            with open(args.output, 'w') as f:
+                json.dump(result, f, indent=2)
+            print(f"\n💾 Wallet info saved to: {args.output}")
+        
+        print(f"\n{'='*80}")
+        print("Wallet Created Successfully!")
+        print(f"{'='*80}")
+        print(json.dumps(result, indent=2))
+        
+    except Exception as e:
+        print(f"\n❌ Error: {e}")
+        import traceback
+        traceback.print_exc()
+        return 1
+    
+    return 0
+
+
+if __name__ == "__main__":
+    import sys
+    sys.exit(main())
+

traia_iatp/core/__init__.py

@@ -0,0 +1,43 @@
+"""Core data models for IATP."""
+
+from .models import (
+    # Core server models
+    MCPServer,
+    MCPServerType,
+    
+    # Agent models  
+    AgentSkill,
+    AgentCapabilities,
+    AgentCard,
+    
+    # IATP protocol models
+    IATPEndpoints,
+    IATPRequest,
+    IATPResponse,
+    
+    # Utility agent models
+    UtilityAgent,
+    UtilityAgentStatus,
+    UtilityAgentRegistryEntry,
+)
+
+__all__ = [
+    # Core server models
+    "MCPServer",
+    "MCPServerType",
+    
+    # Agent models
+    "AgentSkill", 
+    "AgentCapabilities",
+    "AgentCard",
+    
+    # IATP protocol models
+    "IATPEndpoints",
+    "IATPRequest",
+    "IATPResponse",
+    
+    # Utility agent models
+    "UtilityAgent",
+    "UtilityAgentStatus", 
+    "UtilityAgentRegistryEntry",
+]