iwa 0.0.1a2__py3-none-any.whl → 0.0.1a3__py3-none-any.whl

iwa/core/chain/interface.py

@@ -21,8 +21,8 @@ DEFAULT_RPC_TIMEOUT = 10
 class ChainInterface:
     """ChainInterface with rate limiting, retry logic, and RPC rotation support."""
 
-    DEFAULT_MAX_RETRIES = 3
-    DEFAULT_RETRY_DELAY = 0.5
+    DEFAULT_MAX_RETRIES = 6  # Allow trying most/all available RPCs on rate limit
+    DEFAULT_RETRY_DELAY = 1.0  # Base delay between retries (exponential backoff)
 
     chain: SupportedChain
 
@@ -54,42 +54,40 @@ class ChainInterface:
         return "tenderly" in rpc.lower() or "virtual" in rpc.lower()
 
     def init_block_tracking(self):
-        """Initialize block tracking for limit detection."""
+        """Initialize block tracking for limit detection.
+
+        Only enables block limit warnings if we have a valid tenderly config file
+        with initial_block set. Otherwise, leaves _initial_block at 0 which
+        disables the warnings (since we can't accurately track usage without
+        knowing the fork point).
+        """
+        if not self.is_tenderly:
+            return  # Only track for Tenderly vNets
+
         try:
-            self._initial_block = self.web3.eth.block_number
-
-            if self.is_tenderly:
-                try:
-                    from iwa.core.constants import get_tenderly_config_path
-                    from iwa.core.models import TenderlyConfig
-                    from iwa.core.settings import settings
-
-                    profile = settings.tenderly_profile
-                    config_path = get_tenderly_config_path(profile)
-
-                    if config_path.exists():
-                        t_config = TenderlyConfig.load(config_path)
-                        vnet = t_config.vnets.get(self.chain.name)
-                        if not vnet:
-                            vnet = t_config.vnets.get(self.chain.name.lower())
-
-                        if vnet and vnet.initial_block > 0:
-                            self._initial_block = vnet.initial_block
-                            logger.info(
-                                f"Tenderly detected! Limit tracking relative to genesis block: {self._initial_block}"
-                            )
-                        else:
-                            logger.warning(
-                                f"Tenderly detected but no initial_block in config. using session start: {self._initial_block}"
-                            )
-
-                    logger.warning(
-                        "Monitoring Tenderly vNet block usage (Limit ~50 blocks from vNet start)"
-                    )
-                except Exception as ex:
-                    logger.warning(f"Failed to load Tenderly config for block tracking: {ex}")
-        except Exception as e:
-            logger.warning(f"Failed to init block tracking: {e}")
+            from iwa.core.constants import get_tenderly_config_path
+            from iwa.core.models import TenderlyConfig
+
+            profile = Config().core.tenderly_profile
+            config_path = get_tenderly_config_path(profile)
+
+            if not config_path.exists():
+                logger.debug(f"Tenderly config not found at {config_path}, skipping block tracking")
+                return
+
+            t_config = TenderlyConfig.load(config_path)
+            vnet = t_config.vnets.get(self.chain.name)
+            if not vnet:
+                vnet = t_config.vnets.get(self.chain.name.lower())
+
+            if vnet and vnet.initial_block > 0:
+                self._initial_block = vnet.initial_block
+                logger.info(f"Tenderly block tracking enabled (genesis: {self._initial_block})")
+            else:
+                logger.debug(f"Tenderly config exists but no initial_block for {self.chain.name}")
+
+        except Exception as ex:
+            logger.warning(f"Failed to load Tenderly config for block tracking: {ex}")
 
     def check_block_limit(self, show_progress_bar: bool = False):
         """Check if approaching block limit (heuristic).
@@ -160,7 +158,13 @@ class ChainInterface:
         """Initialize Web3 with current RPC."""
         rpc_url = self.chain.rpcs[self._current_rpc_index] if self.chain.rpcs else ""
         raw_web3 = Web3(Web3.HTTPProvider(rpc_url, request_kwargs={"timeout": DEFAULT_RPC_TIMEOUT}))
-        self.web3 = RateLimitedWeb3(raw_web3, self._rate_limiter, self)
+
+        # Use duck typing to check if current web3 is a RateLimitedWeb3 wrapper
+        # (isinstance check fails when RateLimitedWeb3 is mocked in tests)
+        if hasattr(self, "web3") and hasattr(self.web3, "set_backend"):
+            self.web3.set_backend(raw_web3)
+        else:
+            self.web3 = RateLimitedWeb3(raw_web3, self._rate_limiter, self)
 
     def _is_rate_limit_error(self, error: Exception) -> bool:
         """Check if error is a rate limit (429) error."""
@@ -268,30 +272,16 @@ class ChainInterface:
         if not self.chain.rpcs or len(self.chain.rpcs) <= 1:
             return False
 
-        original_index = self._current_rpc_index
-        attempts = 0
-
-        while attempts < len(self.chain.rpcs) - 1:
-            self._current_rpc_index = (self._current_rpc_index + 1) % len(self.chain.rpcs)
-            attempts += 1
-
-            if self._rpc_failure_counts.get(self._current_rpc_index, 0) >= 5:
-                continue
-
-            logger.info(f"Rotating RPC for {self.chain.name} to index {self._current_rpc_index}")
-            self._init_web3()
-
-            if self.check_rpc_health():
-                return True
-            else:
-                logger.warning(f"RPC at index {self._current_rpc_index} failed health check")
-                self._rpc_failure_counts[self._current_rpc_index] = (
-                    self._rpc_failure_counts.get(self._current_rpc_index, 0) + 1
-                )
-
-        self._current_rpc_index = original_index
+        # Simple Round Robin rotation
+        # We don't check health here because the health check itself might consume rate limits
+        # or fail flakily. Better to just switch and try the operation.
+        self._current_rpc_index = (self._current_rpc_index + 1) % len(self.chain.rpcs)
         self._init_web3()
-        return False
+
+        logger.info(
+            f"Rotated RPC for {self.chain.name} to index {self._current_rpc_index}: {self.chain.rpcs[self._current_rpc_index]}"
+        )
+        return True
 
     def check_rpc_health(self) -> bool:
         """Check if the current RPC is healthy."""

iwa/core/chain/models.py

@@ -5,7 +5,7 @@ from typing import Dict, List, Optional
 from pydantic import BaseModel
 
 from iwa.core.models import EthereumAddress
-from iwa.core.settings import settings
+from iwa.core.secrets import secrets
 from iwa.core.utils import singleton
 
 
@@ -75,8 +75,8 @@ class Gnosis(SupportedChain):
     def __init__(self, **data):
         """Initialize with RPCs from settings (after testing override is applied)."""
         super().__init__(**data)
-        if not self.rpcs and settings.gnosis_rpc:
-            self.rpcs = settings.gnosis_rpc.get_secret_value().split(",")
+        if not self.rpcs and secrets.gnosis_rpc:
+            self.rpcs = secrets.gnosis_rpc.get_secret_value().split(",")
 
 
 @singleton
@@ -95,8 +95,8 @@ class Ethereum(SupportedChain):
     def __init__(self, **data):
         """Initialize with RPCs from settings (after testing override is applied)."""
         super().__init__(**data)
-        if not self.rpcs and settings.ethereum_rpc:
-            self.rpcs = settings.ethereum_rpc.get_secret_value().split(",")
+        if not self.rpcs and secrets.ethereum_rpc:
+            self.rpcs = secrets.ethereum_rpc.get_secret_value().split(",")
 
 
 @singleton
@@ -115,8 +115,8 @@ class Base(SupportedChain):
     def __init__(self, **data):
         """Initialize with RPCs from settings (after testing override is applied)."""
         super().__init__(**data)
-        if not self.rpcs and settings.base_rpc:
-            self.rpcs = settings.base_rpc.get_secret_value().split(",")
+        if not self.rpcs and secrets.base_rpc:
+            self.rpcs = secrets.base_rpc.get_secret_value().split(",")
 
 
 @singleton

iwa/core/chain/rate_limiter.py

@@ -152,17 +152,19 @@ class RateLimitedEth:
             delattr(self._eth, name)
 
     def _wrap_with_rate_limit(self, method, method_name):
-        """Wrap a method with rate limiting and error handling."""
+        """Wrap a method with rate limiting.
+
+        Note: Error handling (rotation, retry) is NOT done here.
+        It is the responsibility of `ChainInterface.with_retry()` to handle
+        errors and rotate RPCs as needed. This wrapper only ensures
+        rate limiting.
+        """
 
         def wrapper(*args, **kwargs):
             if not self._rate_limiter.acquire(timeout=30.0):
                 raise TimeoutError(f"Rate limit timeout waiting for {method_name}")
 
-            try:
-                return method(*args, **kwargs)
-            except Exception as e:
-                self._chain_interface._handle_rpc_error(e)
-                raise
+            return method(*args, **kwargs)
 
         return wrapper
 
@@ -178,14 +180,23 @@ class RateLimitedWeb3:
         self._rate_limiter = rate_limiter
         self._chain_interface = chain_interface
         self._eth_wrapper = None
+        # Initialize eth wrapper immediately
+        self._update_eth_wrapper()
+
+    def set_backend(self, new_web3):
+        """Update the underlying Web3 instance (hot-swap)."""
+        self._web3 = new_web3
+        self._update_eth_wrapper()
+
+    def _update_eth_wrapper(self):
+        """Update the eth wrapper to point to the current _web3.eth."""
+        self._eth_wrapper = RateLimitedEth(
+            self._web3.eth, self._rate_limiter, self._chain_interface
+        )
 
     @property
     def eth(self):
         """Return rate-limited eth interface."""
-        if self._eth_wrapper is None:
-            self._eth_wrapper = RateLimitedEth(
-                self._web3.eth, self._rate_limiter, self._chain_interface
-            )
         return self._eth_wrapper
 
     def __getattr__(self, name):

iwa/core/cli.py

@@ -67,6 +67,31 @@ def account_list(
     )
 
 
+@wallet_cli.command("mnemonic")
+def show_mnemonic():
+    """Show the master account mnemonic (requires password)"""
+    key_storage = KeyStorage()
+    try:
+        mnemonic = key_storage.decrypt_mnemonic()
+        print("\n" + "=" * 60)
+        print("📜 MASTER ACCOUNT MNEMONIC (BIP-39)")
+        print("=" * 60)
+        print("\nWrite down these 24 words and store them in a safe place.")
+        print("-" * 60)
+        words = mnemonic.split()
+        for i in range(0, 24, 4):
+            print(
+                f"  {i + 1:2}. {words[i]:12}  {i + 2:2}. {words[i + 1]:12}  "
+                f"{i + 3:2}. {words[i + 2]:12}  {i + 4:2}. {words[i + 3]:12}"
+            )
+        print("-" * 60)
+        print("\n⚠️  Keep this phrase secret! Anyone with it can access your funds.")
+        print("=" * 60)
+    except Exception as e:
+        typer.echo(f"Error: {e}")
+        raise typer.Exit(code=1) from e
+
+
 @wallet_cli.command("send")
 def account_send(
     from_address_or_tag: str = typer.Option(..., "--from", "-f", help="From address or tag"),
@@ -164,10 +189,10 @@ def web_server(
     host: str = typer.Option("127.0.0.1", "--host", "-h", help="Host to listen on"),
 ):
     """Start Web Interface."""
-    from iwa.core.settings import settings
+    from iwa.core.models import Config
     from iwa.web.server import run_server
 
-    server_port = port or settings.web_port
+    server_port = port or Config().core.web_port
     typer.echo(f"Starting web server on http://{host}:{server_port}")
     run_server(host=host, port=server_port)
 

iwa/core/constants.py

@@ -6,14 +6,15 @@ from iwa.core.types import EthereumAddress
 
 PROJECT_ROOT = Path(__file__).parent.parent.parent.parent
 
-# Data directory for sensitive/runtime files
-DATA_DIR = PROJECT_ROOT / "data"
+# Data directory for runtime files
+DATA_DIR = Path("data")
 
-SECRETS_PATH = DATA_DIR / "secrets.env"
+# secrets.env is at project root (NOT in data/)
+SECRETS_PATH = Path("secrets.env")
 CONFIG_PATH = DATA_DIR / "config.yaml"
 WALLET_PATH = DATA_DIR / "wallet.json"
 BACKUP_DIR = DATA_DIR / "backup"
-TENDERLY_CONFIG_PATH = PROJECT_ROOT / "tenderly.yaml"
+TENDERLY_CONFIG_PATH = Path("tenderly.yaml")
 
 ABI_PATH = PROJECT_ROOT / "src" / "iwa" / "core" / "contracts" / "abis"
 
@@ -25,4 +26,4 @@ DEFAULT_MECH_CONTRACT_ADDRESS = EthereumAddress("0x77af31De935740567Cf4FF1986D04
 
 def get_tenderly_config_path(profile: int = 1) -> Path:
     """Get the path to a profile-specific Tenderly config file."""
-    return PROJECT_ROOT / f"tenderly_{profile}.yaml"
+    return Path(f"tenderly_{profile}.yaml")

iwa/core/contracts/contract.py

@@ -54,11 +54,20 @@ class ContractInstance:
             else:
                 self.abi = contract_abi
 
-        self.contract: Contract = self.chain_interface.web3.eth.contract(
-            address=self.address, abi=self.abi
-        )
+        self._contract_cache = None
         self.error_selectors = self.load_error_selectors()
 
+    @property
+    def contract(self) -> Contract:
+        """Get contract instance using the current Web3 provider.
+
+        This property ensures that after an RPC rotation, contract calls
+        use the updated provider instead of the original one.
+        """
+        # Always create a fresh contract to use the current Web3 provider
+        # This is necessary because RPC rotation changes the underlying provider
+        return self.chain_interface.web3.eth.contract(address=self.address, abi=self.abi)
+
     def load_error_selectors(self) -> Dict[str, Any]:
         """Load error selectors from the contract ABI."""
         selectors = {}
@@ -183,7 +192,10 @@ class ContractInstance:
         """
         method = getattr(self.contract.functions, method_name)
         try:
-            return method(*args).call()
+            return self.chain_interface.with_retry(
+                lambda: method(*args).call(),
+                operation_name=f"call {method_name} on {self.name}",
+            )
         except Exception as e:
             error_data = self._extract_error_data(e)
             if error_data:

iwa/core/ipfs.py

@@ -0,0 +1,149 @@
+"""IPFS utilities for pushing and retrieving data.
+
+This module provides functionality to push metadata to IPFS using
+direct HTTP API calls, avoiding heavy dependencies like open-aea.
+"""
+
+import hashlib
+import json
+import uuid
+from typing import Any, Dict, Optional, Tuple
+
+import aiohttp
+from multiformats import CID
+
+from iwa.core.models import Config
+
+
+def _compute_cid_v1_hex(data: bytes) -> str:
+    """Compute CIDv1 hex representation from raw data.
+
+    This creates a CIDv1 with:
+    - multibase: 'f' (base16 lowercase)
+    - version: 1
+    - codec: raw (0x55)
+    - multihash: sha2-256
+
+    :param data: The raw data bytes.
+    :return: The CIDv1 as hex string (f01...).
+    """
+    # SHA-256 hash
+    digest = hashlib.sha256(data).digest()
+
+    # Build CIDv1: raw codec (0x55), sha2-256 multihash (0x12), 32 bytes length (0x20)
+    cid = CID("base16", 1, "raw", ("sha2-256", digest))
+    return str(cid)
+
+
+async def push_to_ipfs_async(
+    data: bytes,
+    api_url: Optional[str] = None,
+    pin: bool = True,
+) -> Tuple[str, str]:
+    """Push raw data to IPFS using the HTTP API.
+
+    :param data: The data bytes to push.
+    :param api_url: Optional IPFS API URL. Defaults to IPFS_API_URL env var or localhost.
+    :param pin: Whether to pin the content (default True).
+    :return: Tuple of (CIDv1 string, CIDv1 hex representation).
+    """
+    url = api_url or Config().core.ipfs_api_url
+    endpoint = f"{url}/api/v0/add"
+
+    params = {"pin": str(pin).lower(), "cid-version": "1"}
+
+    # Create multipart form data
+    form = aiohttp.FormData()
+    form.add_field("file", data, filename="data", content_type="application/octet-stream")
+
+    async with aiohttp.ClientSession() as session:
+        async with session.post(endpoint, data=form, params=params) as response:
+            response.raise_for_status()
+            result = await response.json()
+
+    cid_str = result["Hash"]
+    cid = CID.decode(cid_str)
+
+    # Convert to hex representation (f01 prefix for base16 + CIDv1)
+    # We need to reconstruct with the multihash as a tuple (name, digest)
+    cid_hex = str(CID("base16", cid.version, cid.codec, (cid.hashfun.name, cid.raw_digest)))
+
+    return cid_str, cid_hex
+
+
+def push_to_ipfs_sync(
+    data: bytes,
+    api_url: Optional[str] = None,
+    pin: bool = True,
+) -> Tuple[str, str]:
+    """Push raw data to IPFS using the HTTP API (synchronous version).
+
+    :param data: The data bytes to push.
+    :param api_url: Optional IPFS API URL. Defaults to IPFS_API_URL env var or localhost.
+    :param pin: Whether to pin the content (default True).
+    :return: Tuple of (CIDv1 string, CIDv1 hex representation).
+    """
+    import requests
+
+    url = api_url or Config().core.ipfs_api_url
+    endpoint = f"{url}/api/v0/add"
+
+    params = {"pin": str(pin).lower(), "cid-version": "1"}
+
+    files = {"file": ("data", data, "application/octet-stream")}
+
+    response = requests.post(endpoint, files=files, params=params, timeout=60)
+    response.raise_for_status()
+    result = response.json()
+
+    cid_str = result["Hash"]
+    cid = CID.decode(cid_str)
+
+    # Convert to hex representation (f01 prefix for base16 + CIDv1)
+    # We need to reconstruct with the multihash as a tuple (name, digest)
+    cid_hex = str(CID("base16", cid.version, cid.codec, (cid.hashfun.name, cid.raw_digest)))
+
+    return cid_str, cid_hex
+
+
+def push_metadata_to_ipfs(
+    metadata: Dict[str, Any],
+    extra_attributes: Optional[Dict[str, Any]] = None,
+    api_url: Optional[str] = None,
+) -> Tuple[str, str]:
+    """Push a metadata dict to IPFS synchronously.
+
+    A unique nonce is added automatically to ensure uniqueness.
+
+    :param metadata: Metadata dictionary to push.
+    :param extra_attributes: Extra attributes to include in the metadata.
+    :param api_url: Optional IPFS API URL.
+    :return: Tuple of (truncated hash with 0x prefix for contract calls, full CID hex).
+    """
+    data = {**metadata, "nonce": str(uuid.uuid4())}
+    if extra_attributes:
+        data.update(extra_attributes)
+
+    json_bytes = json.dumps(data, separators=(",", ":")).encode("utf-8")
+    _, cid_hex = push_to_ipfs_sync(json_bytes, api_url)
+
+    # The truncated hash format expected by mech contracts: 0x + hex after the f01 prefix
+    # CIDv1 hex format: f01{codec}{multihash} -> we want just the multihash part
+    # For compatibility with triton, we return "0x" + cid_hex[9:] (skip f01 + 2-byte codec)
+    truncated_hash = "0x" + cid_hex[9:]
+
+    return truncated_hash, cid_hex
+
+
+def metadata_to_request_data(
+    metadata: Dict[str, Any],
+    api_url: Optional[str] = None,
+) -> bytes:
+    """Convert a metadata dict to mech request data by pushing to IPFS.
+
+    :param metadata: Metadata dictionary (typically contains 'prompt', 'tool', etc.).
+    :param api_url: Optional IPFS API URL.
+    :return: The request data as bytes (truncated IPFS hash).
+    """
+    truncated_hash, _ = push_metadata_to_ipfs(metadata, api_url=api_url)
+    return bytes.fromhex(truncated_hash[2:])