traia-iatp 0.1.2__py3-none-any.whl → 0.1.67__py3-none-any.whl

traia_iatp/contracts/data/addresses/contract-addresses.json

@@ -0,0 +1,17 @@
+{
+    "localhost": {
+        "IATPWalletImplementation": "0x5FC8d32690cc91D4c39d9d3abcBD16989F875707",
+        "RoleManagerImplementation": "0x5FbDB2315678afecb367f032d93F642f64180aa3",
+        "Congress": "0x94Fc9eddBd1779542b78eb92F0569762603876e2",
+        "IATPSettlementLayerImplementation": "0xCf7Ed3AccA5a467e9e704C703E8D87F634fB0Fc9",
+        "IATPWalletFactoryImplementation": "0x0165878A594ca255338adfa4d48449f69242Eb8F"
+    },
+    "sepolia": {
+        "Congress": "0x94Fc9eddBd1779542b78eb92F0569762603876e2",
+        "TraiaCongressMembersRegistry": "0x3B685403b195f16D103b42FCf56F848A278d6049",
+        "IATPWalletImplementation": "0xCdc251C242Cc9d2289d9D20355a02425A040952b",
+        "RoleManagerImplementation": "0x585AD85FCFBec3B1503E50b46407bF65d4006560",
+        "IATPSettlementLayerImplementation": "0xfe28b67C848D479858C8279dcEB50D4b894420Da",
+        "IATPWalletFactoryImplementation": "0xe423001656e6055094f131C2d86AA6D64032C14D"
+    }
+}

traia_iatp/contracts/data/addresses/contract-proxies.json

@@ -0,0 +1,12 @@
+{
+    "localhost": {
+        "RoleManager": "0xe7f1725E7734CE288F8367e1Bb143E90bb3F0512",
+        "IATPSettlementLayer": "0xDc64a140Aa3E981100a9becA4E685f962f0cF6C9",
+        "IATPWalletFactory": "0xa513E6E4b8f2a923D98304ec87F64353C4D5C853"
+    },
+    "sepolia": {
+        "RoleManager": "0x71d388142EA9194e5b51Eee3FEfe3B87D494dd38",
+        "IATPSettlementLayer": "0x0205ea98258eda5f6C94116a44f9811d8089f110",
+        "IATPWalletFactory": "0x54083Cc03c5D9D408D71D36170Ef01310E0C78fE"
+    }
+}

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,369 @@
+"""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_iatp_wallet(
+    owner_private_key: str,
+    operator_address: Optional[str] = None,
+    create_operator: bool = False,
+    wallet_name: str = "",
+    wallet_type: str = "MCP_SERVER",
+    wallet_description: str = "",
+    network: str = "sepolia",
+    rpc_url: Optional[str] = None,
+    maintainer_private_key: Optional[str] = None
+) -> Dict[str, str]:
+    """Create a new IATPWallet using IATPWalletFactory.
+    
+    Args:
+        owner_private_key: Private key of the wallet owner (REQUIRED INPUT)
+        operator_address: Operator address (REQUIRED unless create_operator=True)
+        create_operator: If True, generates new operator keypair
+        wallet_name: Name for the wallet (e.g., "My MCP Server")
+        wallet_type: Type of wallet - one of: CLIENT, HUMAN, MCP_SERVER, WEB_SERVER, AGENT
+        wallet_description: Description of the wallet/service
+        network: Network name (default: sepolia)
+        rpc_url: Optional RPC URL (uses default if not provided)
+        maintainer_private_key: Optional maintainer key for createWalletFor (uses env/SSM if not provided)
+        
+    Returns:
+        Dictionary with:
+        - wallet_address: Deployed IATPWallet contract address
+        - owner_address: Owner address (from owner_private_key)
+        - operator_address: Operator address
+        - operator_private_key: Operator private key (only if create_operator=True)
+        - network: Network name
+        - transaction_hash: Deployment transaction
+    """
+    # 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_clean = owner_private_key[2:]
+    else:
+        owner_private_key_clean = owner_private_key
+    owner_account = Account.from_key(owner_private_key_clean)
+    print(f"\n👤 Owner Account: {owner_account.address}")
+    
+    # Handle operator
+    operator_private_key_output = None
+    if create_operator:
+        # Generate new operator keypair
+        operator_account = Account.create()
+        operator_address = operator_account.address
+        operator_private_key_output = operator_account.key.hex()
+        
+        print(f"\n🔑 Generated Operator:")
+        print(f"   Address: {operator_address}")
+        print(f"   Private Key: {operator_private_key_output}")
+    elif not operator_address:
+        raise ValueError("operator_address required (or use --create-operator)")
+    else:
+        print(f"\n🔑 Using Provided Operator:")
+        print(f"   Address: {operator_address}")
+    
+    # Map wallet type string to enum value
+    wallet_type_map = {
+        "CLIENT": 0,
+        "HUMAN": 1,
+        "MCP_SERVER": 2,
+        "WEB_SERVER": 3,
+        "AGENT": 4
+    }
+    
+    if isinstance(wallet_type, str):
+        wallet_type_int = wallet_type_map.get(wallet_type.upper())
+        if wallet_type_int is None:
+            raise ValueError(f"Invalid wallet_type: {wallet_type}. Must be one of: {list(wallet_type_map.keys())}")
+    else:
+        wallet_type_int = int(wallet_type)
+    
+    print(f"\n📝 Wallet Metadata:")
+    print(f"   Name: {wallet_name or '(none)'}")
+    print(f"   Type: {list(wallet_type_map.keys())[wallet_type_int]} ({wallet_type_int})")
+    print(f"   Description: {wallet_description[:50] + '...' if len(wallet_description) > 50 else wallet_description or '(none)'}")
+    
+    # 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 creates for someone else)
+        # This is used by backend deployment scripts
+        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}")
+        
+        # Check maintainer balance
+        maintainer_balance = w3.eth.get_balance(caller_account.address)
+        print(f"   Balance: {w3.from_wei(maintainer_balance, 'ether')} ETH")
+        
+        if maintainer_balance < w3.to_wei(0.001, 'ether'):
+            raise ValueError(f"Insufficient maintainer balance: {w3.from_wei(maintainer_balance, 'ether')} ETH (need >= 0.001 ETH)")
+        
+        # Build transaction with metadata
+        tx = factory_contract.functions.createWalletFor(
+            Web3.to_checksum_address(owner_account.address),
+            Web3.to_checksum_address(operator_address),
+            wallet_type_int,  # WalletType enum
+            wallet_name,      # Name
+            wallet_description  # Description
+        ).build_transaction({
+            'from': caller_account.address,
+            'nonce': w3.eth.get_transaction_count(caller_account.address),
+            'gas': 3000000,
+            'maxFeePerGas': w3.to_wei('2', 'gwei'),
+            'maxPriorityFeePerGas': w3.to_wei('0.1', 'gwei'),
+            'chainId': w3.eth.chain_id
+        })
+        
+        # Estimate gas
+        try:
+            estimated_gas = w3.eth.estimate_gas(tx)
+            tx['gas'] = int(estimated_gas * 1.2)
+            print(f"\n⛽ Estimated gas: {estimated_gas}")
+        except Exception as e:
+            print(f"\n⚠️  Gas estimation failed: {e}, using default")
+        
+        # Sign and send
+        signed_tx = w3.eth.account.sign_transaction(tx, caller_account.key)
+        
+    else:
+        # Use createWallet (owner creates their own wallet)
+        # This is the normal path for developers using the CLI
+        print(f"\n📞 Calling createWallet() as owner")
+        print(f"   Owner: {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 < w3.to_wei(0.001, 'ether'):
+            raise ValueError(f"Insufficient owner balance: {w3.from_wei(owner_balance, 'ether')} ETH (need >= 0.001 ETH for gas)")
+        
+        # Build transaction
+        tx = factory_contract.functions.createWallet(
+            Web3.to_checksum_address(operator_address),
+            wallet_type_int,  # WalletType enum
+            wallet_name,      # Name
+            wallet_description  # Description
+        ).build_transaction({
+            'from': owner_account.address,
+            'nonce': w3.eth.get_transaction_count(owner_account.address),
+            'gas': 3000000,
+            'maxFeePerGas': w3.to_wei('2', 'gwei'),
+            'maxPriorityFeePerGas': w3.to_wei('0.1', 'gwei'),
+            'chainId': w3.eth.chain_id
+        })
+        
+        # Estimate gas
+        try:
+            estimated_gas = w3.eth.estimate_gas(tx)
+            tx['gas'] = int(estimated_gas * 1.2)
+            print(f"\n⛽ Estimated gas: {estimated_gas}")
+        except Exception as e:
+            print(f"\n⚠️  Gas estimation failed: {e}, using default")
+        
+        # Sign and send with owner key
+        signed_tx = w3.eth.account.sign_transaction(tx, owner_account.key)
+    
+    print(f"\n🚀 Sending transaction...")
+    raw_tx = signed_tx.raw_transaction if hasattr(signed_tx, 'raw_transaction') else signed_tx.rawTransaction
+    tx_hash = w3.eth.send_raw_transaction(raw_tx)
+    print(f"   TX Hash: {tx_hash.hex()}")
+    
+    print(f"\n⏳ Waiting for confirmation...")
+    tx_receipt = w3.eth.wait_for_transaction_receipt(tx_hash, timeout=180)
+    
+    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_address = None
+        try:
+            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🎉 IATPWallet Deployed!")
+                print(f"   Wallet Address: {wallet_address}")
+                print(f"   Owner: {logs[0]['args']['owner']}")
+                print(f"   Operator: {logs[0]['args']['operatorAddress']}")
+        except Exception as e:
+            print(f"⚠️  Could not parse event logs: {e}")
+        
+        # Fallback: Get wallet using getWalletForOwner
+        if not wallet_address:
+            try:
+                wallet_address = factory_contract.functions.getWalletForOwner(
+                    Web3.to_checksum_address(owner_account.address)
+                ).call()
+                print(f"\n🎉 IATPWallet Deployed!")
+                print(f"   Wallet Address: {wallet_address}")
+            except Exception as e:
+                raise Exception(f"Could not retrieve wallet address: {e}")
+        
+        # Build result dictionary
+        result = {
+            "wallet_address": wallet_address,
+            "owner_address": owner_account.address,
+            "operator_address": operator_address,
+            "network": network,
+            "transaction_hash": tx_hash.hex(),
+            "gas_used": tx_receipt['gasUsed'],
+            "block_number": tx_receipt['blockNumber']
+        }
+        
+        # Include operator private key if we generated it
+        if operator_private_key_output:
+            result["operator_private_key"] = operator_private_key_output
+        
+        return result
+    else:
+        raise Exception(f"Transaction failed: {tx_receipt}")
+
+
+def main():
+    """CLI entry point for IATP wallet creation."""
+    import argparse
+    
+    parser = argparse.ArgumentParser(description="Create IATPWallet using IATPWalletFactory")
+    parser.add_argument("--owner-key", required=True, help="Owner's private key (REQUIRED INPUT)")
+    parser.add_argument("--operator-address", help="Operator address (required unless --create-operator)")
+    parser.add_argument("--create-operator", action="store_true", help="Generate new operator keypair")
+    parser.add_argument("--wallet-name", default="", help="Name for the wallet")
+    parser.add_argument("--wallet-type", default="MCP_SERVER", 
+                       help="Wallet type: CLIENT, HUMAN, MCP_SERVER, WEB_SERVER, AGENT (default: MCP_SERVER)")
+    parser.add_argument("--wallet-description", default="", help="Description of the wallet/service")
+    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 (or use MAINTAINER_PRIVATE_KEY env var)")
+    parser.add_argument("--output", help="Output file for wallet info (JSON)")
+    
+    args = parser.parse_args()
+    
+    try:
+        result = create_iatp_wallet(
+            owner_private_key=args.owner_key,
+            operator_address=args.operator_address,
+            create_operator=args.create_operator,
+            wallet_name=args.wallet_name,
+            wallet_type=args.wallet_type,
+            wallet_description=args.wallet_description,
+            network=args.network,
+            rpc_url=args.rpc_url,
+            maintainer_private_key=args.maintainer_key
+        )
+        
+        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("IATPWallet 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())
+