iwa 0.0.1a2__tar.gz → 0.0.1a4__tar.gz

{iwa-0.0.1a2/src/iwa.egg-info → iwa-0.0.1a4}/PKG-INFO

@@ -1,7 +1,7 @@
 Metadata-Version: 2.4
 Name: iwa
-Version: 0.0.1a2
-Summary: Add your description here
+Version: 0.0.1a4
+Summary: A secure, modular, and plugin-based framework for crypto agents and ops
 Requires-Python: <4.0,>=3.12
 Description-Content-Type: text/markdown
 License-File: LICENSE
@@ -33,6 +33,8 @@ Requires-Dist: nest-asyncio>=1.6.0
 Requires-Dist: aiohttp>=3.13.3
 Requires-Dist: pynacl>=1.6.2
 Requires-Dist: urllib3>=2.6.3
+Requires-Dist: multiformats>=0.3.1
+Requires-Dist: requests>=2.32.0
 Dynamic: license-file
 
 # Iwa
@@ -160,7 +162,8 @@ just test
 ### Security Checks
 
 ```bash
-just security  # Runs gitleaks, bandit, and pip-audit
+just security      # Runs gitleaks, bandit, and pip-audit
+just wallet-check  # Verifies password, keys, and mnemonic integrity
 ```
 
 ### Docker

{iwa-0.0.1a2 → iwa-0.0.1a4}/README.md

@@ -123,7 +123,8 @@ just test
 ### Security Checks
 
 ```bash
-just security  # Runs gitleaks, bandit, and pip-audit
+just security      # Runs gitleaks, bandit, and pip-audit
+just wallet-check  # Verifies password, keys, and mnemonic integrity
 ```
 
 ### Docker

{iwa-0.0.1a2 → iwa-0.0.1a4}/pyproject.toml

@@ -1,7 +1,7 @@
 [project]
 name = "iwa"
-version = "0.0.1-alpha2"
-description = "Add your description here"
+version = "0.0.1a4"
+description = "A secure, modular, and plugin-based framework for crypto agents and ops"
 readme = "README.md"
 requires-python = ">=3.12,<4.0"
 dependencies = [
@@ -33,10 +33,16 @@ dependencies = [
     "aiohttp>=3.13.3",
     "pynacl>=1.6.2",
     "urllib3>=2.6.3",
+    "multiformats>=0.3.1",
+    "requests>=2.32.0",
 ]
 
 [project.scripts]
 iwa = "iwa.core.cli:iwa_cli"
+iwa-wallet-check = "iwa.tools.wallet_check:check_wallet"
+iwa-reset-tenderly = "iwa.tools.reset_tenderly:main"
+iwa-reset-env = "iwa.tools.reset_env:main"
+iwa-check-profile = "iwa.tools.check_profile:main"
 
 [dependency-groups]
 dev = [
@@ -57,9 +63,15 @@ dev = [
 requires = ["setuptools>=61.0", "wheel"]
 build-backend = "setuptools.build_meta"
 
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.setuptools.package-data]
+"*" = ["*.json", "*.yaml", "*.yml", "*.html", "*.css", "*.js"]
+
 [tool.ruff]
 line-length = 100
-target-version = "0.0.1-alpha2"
+target-version = "0.0.1a4"
 fix = true
 
 [tool.ruff.lint]

{iwa-0.0.1a2 → iwa-0.0.1a4}/src/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-0.0.1a2 → iwa-0.0.1a4}/src/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-0.0.1a2 → iwa-0.0.1a4}/src/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-0.0.1a2 → iwa-0.0.1a4}/src/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-0.0.1a2 → iwa-0.0.1a4}/src/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")