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

traia_iatp/scripts/create_wallet.py

@@ -0,0 +1,244 @@
+#!/usr/bin/env python3
+"""Create an IATPWallet for a user.
+
+This script:
+1. Takes an owner private key as input
+2. Generates a new operator keypair
+3. Calls IATPWalletFactory.createWallet() to deploy an IATPWallet
+4. Returns the operator keys and wallet address
+
+Usage:
+    uv run python -m traia_iatp.scripts.create_wallet \\
+        --owner-key 0x... \\
+        --network sepolia \\
+        [--wait-confirmations 2]
+"""
+
+import argparse
+import json
+import logging
+import sys
+from eth_account import Account
+from web3 import Web3
+
+from traia_iatp.contracts import (
+    get_contract_address,
+    load_contract,
+    ContractName
+)
+
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - %(levelname)s - %(message)s'
+)
+logger = logging.getLogger(__name__)
+
+
+def create_wallet(
+    owner_private_key: str,
+    network: str = "sepolia",
+    wait_confirmations: int = 2
+) -> dict:
+    """Create an IATP Wallet for an owner.
+    
+    Args:
+        owner_private_key: Owner's private key (0x...)
+        network: Network name (default: "sepolia")
+        wait_confirmations: Number of confirmations to wait (default: 2)
+        
+    Returns:
+        Dict with operator keys and wallet address:
+        {
+            "owner_address": "0x...",
+            "operator_address": "0x...",
+            "operator_private_key": "0x...",
+            "wallet_address": "0x...",
+            "transaction_hash": "0x...",
+            "network": "sepolia"
+        }
+    """
+    logger.info(f"Creating IATP Wallet on {network}")
+    
+    # Create owner account
+    if not owner_private_key.startswith("0x"):
+        owner_private_key = f"0x{owner_private_key}"
+    
+    owner_account = Account.from_key(owner_private_key)
+    logger.info(f"Owner address: {owner_account.address}")
+    
+    # Generate new operator keypair
+    operator_account = Account.create()
+    logger.info(f"Generated operator address: {operator_account.address}")
+    logger.info(f"Operator private key: {operator_account.key.hex()}")
+    
+    # Load IATPWalletFactory contract
+    factory_contract, w3 = load_contract(
+        ContractName.IATP_WALLET_FACTORY,
+        network=network
+    )
+    
+    factory_address = factory_contract.address
+    logger.info(f"IATPWalletFactory address: {factory_address}")
+    
+    # Check owner balance
+    owner_balance = w3.eth.get_balance(owner_account.address)
+    logger.info(f"Owner balance: {w3.from_wei(owner_balance, 'ether')} ETH")
+    
+    if owner_balance == 0:
+        logger.error("Owner has no ETH for gas. Please fund the account.")
+        raise ValueError("Insufficient balance for gas")
+    
+    # Build transaction to create wallet
+    logger.info("Building createWallet transaction...")
+    
+    tx = factory_contract.functions.createWallet(
+        operator_account.address
+    ).build_transaction({
+        'from': owner_account.address,
+        'nonce': w3.eth.get_transaction_count(owner_account.address),
+        'gas': 2000000,  # Estimate gas
+        'gasPrice': w3.eth.gas_price,
+        'chainId': w3.eth.chain_id
+    })
+    
+    # Sign transaction
+    signed_tx = owner_account.sign_transaction(tx)
+    
+    # Send transaction
+    logger.info("Sending transaction...")
+    tx_hash = w3.eth.send_raw_transaction(signed_tx.raw_transaction)
+    logger.info(f"Transaction hash: {tx_hash.hex()}")
+    
+    # Wait for confirmation
+    logger.info(f"Waiting for {wait_confirmations} confirmation(s)...")
+    tx_receipt = w3.eth.wait_for_transaction_receipt(tx_hash, timeout=300)
+    
+    if tx_receipt['status'] != 1:
+        logger.error("Transaction failed!")
+        raise Exception(f"Transaction failed: {tx_hash.hex()}")
+    
+    logger.info(f"Transaction confirmed in block {tx_receipt['blockNumber']}")
+    
+    # Parse WalletCreated event to get wallet address
+    wallet_address = None
+    for log in tx_receipt['logs']:
+        try:
+            event = factory_contract.events.WalletCreated().process_log(log)
+            wallet_address = event['args']['wallet']
+            logger.info(f"✅ IATPWallet created: {wallet_address}")
+            break
+        except:
+            continue
+    
+    if not wallet_address:
+        logger.error("Could not find WalletCreated event in logs")
+        raise Exception("Wallet address not found in transaction logs")
+    
+    # Return result
+    result = {
+        "owner_address": owner_account.address,
+        "operator_address": operator_account.address,
+        "operator_private_key": operator_account.key.hex(),
+        "wallet_address": wallet_address,
+        "transaction_hash": tx_hash.hex(),
+        "block_number": tx_receipt['blockNumber'],
+        "network": network,
+        "chain_id": w3.eth.chain_id
+    }
+    
+    return result
+
+
+def main():
+    """Main CLI entry point."""
+    parser = argparse.ArgumentParser(
+        description="Create an IATP Wallet via IATPWalletFactory",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog="""
+Examples:
+  # Create wallet on Sepolia
+  uv run python -m traia_iatp.scripts.create_wallet \\
+      --owner-key 0x0cdda2d9d744d6d2a3ba4b30ac51227590f0e8f44cf5251bb1ed0941d677c0a4 \\
+      --network sepolia
+  
+  # Create wallet with output to JSON file
+  uv run python -m traia_iatp.scripts.create_wallet \\
+      --owner-key 0x... \\
+      --network sepolia \\
+      --output wallet_config.json
+        """
+    )
+    
+    parser.add_argument(
+        "--owner-key",
+        required=True,
+        help="Owner's private key (0x...)"
+    )
+    
+    parser.add_argument(
+        "--network",
+        default="sepolia",
+        choices=["sepolia", "base-sepolia", "arbitrum-sepolia", "localhost"],
+        help="Network to deploy on (default: sepolia)"
+    )
+    
+    parser.add_argument(
+        "--wait-confirmations",
+        type=int,
+        default=2,
+        help="Number of confirmations to wait (default: 2)"
+    )
+    
+    parser.add_argument(
+        "--output",
+        "-o",
+        type=str,
+        help="Output JSON file path (prints to stdout if not specified)"
+    )
+    
+    parser.add_argument(
+        "--verbose",
+        "-v",
+        action="store_true",
+        help="Enable verbose logging"
+    )
+    
+    args = parser.parse_args()
+    
+    if args.verbose:
+        logging.getLogger().setLevel(logging.DEBUG)
+    
+    try:
+        # Create wallet
+        result = create_wallet(
+            owner_private_key=args.owner_key,
+            network=args.network,
+            wait_confirmations=args.wait_confirmations
+        )
+        
+        # Output result
+        output_json = json.dumps(result, indent=2)
+        
+        if args.output:
+            with open(args.output, 'w') as f:
+                f.write(output_json)
+            logger.info(f"✅ Configuration saved to: {args.output}")
+        else:
+            print("\n" + "=" * 80)
+            print("IATP Wallet Created Successfully!")
+            print("=" * 80)
+            print(output_json)
+            print("=" * 80)
+        
+        return 0
+        
+    except Exception as e:
+        logger.error(f"Failed to create wallet: {e}")
+        import traceback
+        traceback.print_exc()
+        return 1
+
+
+if __name__ == "__main__":
+    sys.exit(main())
+

traia_iatp/server/a2a_server.py

@@ -39,7 +39,7 @@ class UtilityAgencyExecutor(AgentExecutor):
             # Get the user's request from context
             user_message = context.get_last_user_message()
             if not user_message:
-                event_queue.enqueue_event(
+                await event_queue.enqueue_event(
                     new_agent_text_message("No user message provided")
                 )
                 return
@@ -73,6 +73,10 @@ class UtilityAgencyExecutor(AgentExecutor):
                 new_agent_text_message(f"Error processing request: {str(e)}")
             )
 
+    async def cancel(self, context: RequestContext, event_queue: EventQueue) -> None:
+        """Cancel all tasks."""
+        pass
+
 
 class MCPToolExecutor(AgentExecutor):
     """Agent executor for individual MCP tool execution."""
@@ -89,7 +93,7 @@ class MCPToolExecutor(AgentExecutor):
             # Get tool arguments from context
             user_message = context.get_last_user_message()
             if not user_message:
-                event_queue.enqueue_event(
+                await event_queue.enqueue_event(
                     new_agent_text_message("No arguments provided")
                 )
                 return
@@ -110,7 +114,7 @@ class MCPToolExecutor(AgentExecutor):
             
             try:
                 result = await mcp_client.call_tool(self.tool_name, arguments)
-                event_queue.enqueue_event(
+                await event_queue.enqueue_event(
                     new_agent_text_message(str(result))
                 )
             finally:
@@ -118,7 +122,7 @@ class MCPToolExecutor(AgentExecutor):
                 
         except Exception as e:
             logger.error(f"Error executing MCP tool {self.tool_name}: {e}")
-            event_queue.enqueue_event(
+            await event_queue.enqueue_event(
                 new_agent_text_message(f"Error executing tool: {str(e)}")
             )
 
@@ -162,11 +166,22 @@ def create_a2a_server(
         stateTransitionHistory=False
     )
     
-    # Create agent card
+    # Create agent card with proper URL
+    # For Cloud Run: use PUBLIC_URL or SERVICE_URL environment variable
+    # For local: use http://{host}:{port}
+    import os
+    public_url = os.getenv("PUBLIC_URL") or os.getenv("SERVICE_URL")
+    if public_url:
+        # Cloud Run deployment - use the public URL
+        agent_url = public_url
+    else:
+        # Local deployment - use host:port
+        agent_url = f"http://{host}:{port}"
+    
     agent_card = AgentCard(
         name=agency.name.replace(" ", "_").lower(),
         description=agency.description,
-        url=f"http://{host}:{port}",
+        url=agent_url,
         version="1.0.0",
         capabilities=capabilities,
         skills=skills,
@@ -194,7 +209,7 @@ def create_a2a_server(
     # Create the A2A application
     app = A2AStarletteApplication(
         agent_card=agent_card,
-        request_handler=request_handler
+        http_handler=request_handler
     )
     
     return app

traia_iatp/server/iatp_server_template_generator.py

@@ -117,6 +117,18 @@ class IATPServerTemplateGenerator:
         module_name = package_name
         docker_image = f"traia/{agent_id}:latest"
         
+        # Extract D402 parameters from kwargs (populated by deploy_utility_agent)
+        d402_enabled = kwargs.get("d402_enabled", False)
+        d402_contract_address = kwargs.get("d402_contract_address", "")
+        d402_operator_private_key = kwargs.get("d402_operator_private_key", "")
+        d402_price_usd = kwargs.get("d402_price_usd", "0.01")
+        d402_token_symbol = kwargs.get("d402_token_symbol", "USDC")
+        d402_token_address = kwargs.get("d402_token_address", "")
+        d402_token_decimals = kwargs.get("d402_token_decimals", 6)
+        d402_network = kwargs.get("d402_network", "sepolia")
+        d402_facilitator_url = kwargs.get("d402_facilitator_url", "http://localhost:7070")
+        d402_testing_mode = kwargs.get("d402_testing_mode", "false")
+        
         # Prepare template context
         context = {
             "agent_name": agent_name,
@@ -141,6 +153,17 @@ class IATPServerTemplateGenerator:
             "environment_variables": environment_variables,
             "additional_ignores": additional_ignores,
             "use_uv_lock": False,  # Will be true after first uv sync
+            # D402 payment configuration
+            "d402_enabled": d402_enabled,
+            "d402_contract_address": d402_contract_address,
+            "d402_operator_private_key": d402_operator_private_key,
+            "d402_price_usd": d402_price_usd,
+            "d402_token_symbol": d402_token_symbol,
+            "d402_token_address": d402_token_address,
+            "d402_token_decimals": d402_token_decimals,
+            "d402_network": d402_network,
+            "d402_facilitator_url": d402_facilitator_url,
+            "d402_testing_mode": d402_testing_mode,
             **kwargs
         }
         

traia_iatp/server/templates/.dockerignore.j2

@@ -0,0 +1,48 @@
+# Environment files (should be mounted, not built into image)
+.env
+.env.*
+!.env.example
+
+# Python
+__pycache__/
+*.pyc
+*.pyo
+*.pyd
+.Python
+*.egg-info/
+dist/
+build/
+
+# Git
+.git/
+.gitignore
+
+# IDE
+.vscode/
+.idea/
+*.swp
+*.swo
+
+# OS
+.DS_Store
+Thumbs.db
+
+# UV/Poetry
+.venv/
+venv/
+env/
+
+# Logs
+*.log
+logs/
+
+# Testing
+.pytest_cache/
+.coverage
+htmlcov/
+.tox/
+
+# Documentation
+docs/
+*.md
+!README.md 

traia_iatp/server/templates/Dockerfile.j2

@@ -24,6 +24,28 @@ USER appuser
 # Copy project files
 COPY --chown=appuser:appuser . .
 
+# Copy IATP package if available (for local development only)
+# This Dockerfile works for both local and remote deployments:
+# 
+# LOCAL DEPLOYMENT (via run_local_docker.sh):
+#   - run_local_docker.sh detects local IATP path in pyproject.toml
+#   - Copies IATP to .docker-iatp/IATP before building
+#   - Temporarily modifies pyproject.toml to use file:///tmp/IATP
+#   - Dockerfile finds .docker-iatp/IATP and copies it to /tmp/IATP
+#   - uv install uses the local IATP from /tmp/IATP
+#
+# REMOTE DEPLOYMENT (Cloud Run, etc.):
+#   - .docker-iatp/IATP does NOT exist in build context
+#   - pyproject.toml has published version (traia-iatp>=0.1.40)
+#   - Dockerfile skips IATP copy, uv install uses published package
+#
+RUN if [ -d .docker-iatp/IATP ]; then \
+        cp -r .docker-iatp/IATP /tmp/IATP && \
+        echo "Using local IATP package (local development mode)"; \
+    else \
+        echo "Using published IATP package (remote deployment mode)"; \
+    fi
+
 # Install Python dependencies
 RUN uv venv .venv && \
     uv pip install -r pyproject.toml
@@ -40,7 +62,7 @@ ENV {{ env_var.name }}="{{ env_var.value }}"
 
 # Health check
 HEALTHCHECK --interval=30s --timeout=10s --start-period=40s --retries=3 \
-    CMD curl -f http://localhost:${PORT:-8000}/.well-known/agent.json || exit 1
+    CMD curl -f http://localhost:${PORT:-8000}/.well-known/agent-card.json || exit 1
 
 # Expose port (uses PORT environment variable with default)
 EXPOSE ${PORT:-8000}

traia_iatp/server/templates/README.md

@@ -63,7 +63,7 @@ The templates expect the following variables:
 Use the `UtilityAgencyTemplateGenerator` class to generate agencies:
 
 ```python
-from iatp.server.template_generator import UtilityAgencyTemplateGenerator
+from traia_iatp.server.template_generator import UtilityAgencyTemplateGenerator
 
 generator = UtilityAgencyTemplateGenerator()
 output_path = generator.generate_agency(
@@ -114,7 +114,7 @@ output_dir/
 
 The generated agencies follow the A2A protocol by:
 
-1. **Agent Card**: Exposing agent capabilities at `/.well-known/agent.json`
+1. **Agent Card**: Exposing agent capabilities at `/.well-known/agent-card.json`
 2. **Task Processing**: Handling tasks via POST to `/tasks/send`
 3. **Text I/O**: Supporting text input and output by default
 4. **Request Context**: Processing request context and metadata

traia_iatp/server/templates/README.md.j2

@@ -73,8 +73,8 @@ All configuration is managed through environment variables. See `.env.example` f
 
 The A2A (Agent-to-Agent) protocol defines a minimal set of endpoints for agent communication:
 
-#### 1. **`POST /` (Root Path)** - Main JSON-RPC Endpoint
-This is the primary endpoint for all A2A communication. Despite what you might expect, the A2A library creates the JSON-RPC endpoint at the root path (`/`), not at `/a2a`.
+#### 1. **`POST /a2a`** - Main JSON-RPC Endpoint
+This is the primary endpoint for all A2A communication. The JSON-RPC endpoint is configured at `/a2a` to avoid conflicts with middleware and root path handling.
 
 **Supported Methods:**
 - `message/send` - Send a message to the agent
@@ -97,7 +97,7 @@ This is the primary endpoint for all A2A communication. Despite what you might e
 }
 ```
 
-#### 2. **`GET /.well-known/agent.json`** - Agent Card
+#### 2. **`GET /.well-known/agent-card.json`** - Agent Card
 Returns the agent's capabilities, skills, and metadata following the A2A standard.
 
 **Example Response:**
@@ -135,7 +135,7 @@ Resume a subscription to task events, useful for handling connection drops.
 
 ### How Streaming Works
 
-**Important:** Streaming uses the SAME root endpoint (`/`) as regular requests. The difference is in the request parameters:
+**Important:** Streaming uses the SAME endpoint (`/a2a`) as regular requests. The difference is in the request parameters:
 
 **Regular Request:**
 ```json
@@ -311,7 +311,7 @@ This will log:
 import httpx
 
 # Get agent info
-response = httpx.get("http://localhost:8000/.well-known/agent.json")
+response = httpx.get("http://localhost:8000/.well-known/agent-card.json")
 info = response.json()
 
 # Send a message via A2A (note: endpoint is at root "/", not "/a2a")