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

iwa/plugins/olas/contracts/mech.py

@@ -1,8 +1,9 @@
 """Mech contract interaction."""
 
-from typing import Dict, Optional
+from typing import Any, Dict, Optional
 
 from iwa.core.contracts.contract import ContractInstance
+from iwa.core.ipfs import metadata_to_request_data
 from iwa.core.types import EthereumAddress
 from iwa.plugins.olas.contracts.base import OLAS_ABI_PATH
 
@@ -38,7 +39,13 @@ class MechContract(ContractInstance):
         data: bytes,
         value: Optional[int] = None,
     ) -> Optional[Dict]:
-        """Prepare a request transaction."""
+        """Prepare a request transaction from raw data bytes.
+
+        :param from_address: The address initiating the request.
+        :param data: The raw request data bytes (typically an IPFS hash).
+        :param value: The value to send with the transaction. Defaults to contract price.
+        :return: The prepared transaction dict, or None if preparation fails.
+        """
         if value is None:
             value = self.get_price()
 
@@ -47,3 +54,24 @@ class MechContract(ContractInstance):
             method_kwargs={"data": data},
             tx_params={"from": from_address, "value": value},
         )
+
+    def prepare_request_from_metadata(
+        self,
+        from_address: EthereumAddress,
+        metadata: Dict[str, Any],
+        value: Optional[int] = None,
+    ) -> Optional[Dict]:
+        """Prepare a mech request by pushing metadata to IPFS.
+
+        This method handles the full flow:
+        1. Pushing the metadata JSON to IPFS
+        2. Converting the IPFS hash to request data bytes
+        3. Preparing the request transaction
+
+        :param from_address: The address initiating the request.
+        :param metadata: The metadata dict to push to IPFS (e.g., {"prompt": ..., "tool": ...}).
+        :param value: The value to send with the transaction. Defaults to contract price.
+        :return: The prepared transaction dict, or None if preparation fails.
+        """
+        request_data = metadata_to_request_data(metadata)
+        return self.prepare_request_tx(from_address, request_data, value)

iwa/plugins/olas/plugin.py

@@ -65,9 +65,9 @@ class OlasPlugin(Plugin):
             from safe_eth.eth import EthereumClient
             from safe_eth.safe import Safe
 
-            from iwa.core.settings import settings
+            from iwa.core.secrets import secrets
 
-            rpc_secret = getattr(settings, f"{chain_name}_rpc", None)
+            rpc_secret = getattr(secrets, f"{chain_name}_rpc", None)
             if not rpc_secret:
                 return None, None  # Can't verify, skip
 

iwa/plugins/olas/tests/test_plugin_full.py

@@ -103,14 +103,14 @@ def test_import_services_cli_full(plugin, runner):
 def test_get_safe_signers_edge_cases(plugin):
     """Test _get_safe_signers with various failure scenarios."""
     # 1. No RPC configured
-    with patch("iwa.core.settings.settings") as mock_settings:
+    with patch("iwa.core.secrets.secrets") as mock_settings:
         mock_settings.gnosis_rpc = None
         signers, exists = plugin._get_safe_signers("0x1", "gnosis")
         assert signers is None
         assert exists is None
 
     # 2. Safe doesn't exist (raises exception)
-    with patch("iwa.core.settings.settings") as mock_settings:
+    with patch("iwa.core.secrets.secrets") as mock_settings:
         mock_settings.gnosis_rpc = MagicMock()
         with patch("safe_eth.eth.EthereumClient"), patch("safe_eth.safe.Safe") as mock_safe_cls:
             mock_safe = mock_safe_cls.return_value
@@ -121,7 +121,7 @@ def test_get_safe_signers_edge_cases(plugin):
             assert exists is False
 
     # 3. Success path
-    with patch("iwa.core.settings.settings") as mock_settings:
+    with patch("iwa.core.secrets.secrets") as mock_settings:
         mock_settings.gnosis_rpc = MagicMock()
         with patch("safe_eth.eth.EthereumClient"), patch("safe_eth.safe.Safe") as mock_safe_cls:
             mock_safe = mock_safe_cls.return_value

iwa/plugins/olas/tests/test_staking_integration.py

@@ -247,8 +247,8 @@ def test_staking_contract(tmp_path):  # noqa: C901
                 assert staking.call("nonexistent") == 0
 
                 # Activity checker interactions - nonces now returns [safe_nonce, mech_requests]
-                mock_contract.functions.getMultisigNonces.return_value.call.return_value = [5, 3]
-                staking.activity_checker.contract = mock_contract
+                # Mock via patch since contract is now a property
+                staking.activity_checker.get_multisig_nonces = MagicMock(return_value=(5, 3))
 
                 staking.ts_checkpoint = MagicMock(return_value=0)
 

iwa/tools/__init__.py

@@ -0,0 +1 @@
+"""Tools for IWA."""

iwa/tools/check_profile.py

@@ -3,7 +3,8 @@
 
 import requests
 
-from iwa.core.settings import settings
+from iwa.core.models import Config
+from iwa.core.secrets import secrets
 
 
 def check_rpc_status(rpc_url):
@@ -16,8 +17,8 @@ def check_rpc_status(rpc_url):
 
     headers = {"Content-Type": "application/json"}
     # Include access key if present
-    if settings.tenderly_access_key:
-        headers["X-Access-Key"] = settings.tenderly_access_key.get_secret_value()
+    if secrets.tenderly_access_key:
+        headers["X-Access-Key"] = secrets.tenderly_access_key.get_secret_value()
 
     payload = {"jsonrpc": "2.0", "method": "eth_blockNumber", "params": [], "id": 1}
 
@@ -56,10 +57,10 @@ def check_rpc_status(rpc_url):
 
 def main():
     """Check and display the active Tenderly profile status."""
-    print(f"Active Tenderly Profile: {settings.tenderly_profile}")
+    print(f"Active Tenderly Profile: {Config().core.tenderly_profile}")
 
     # Check Gnosis RPC as primary indicator
-    rpc = settings.gnosis_rpc.get_secret_value() if settings.gnosis_rpc else None
+    rpc = secrets.gnosis_rpc.get_secret_value() if secrets.gnosis_rpc else None
     check_rpc_status(rpc)
 
 

iwa/tools/list_contracts.py

@@ -0,0 +1,136 @@
+"""Tool to list Olas staking contracts status."""
+
+import argparse
+import logging
+
+from rich.console import Console
+from rich.progress import track
+from rich.table import Table
+
+from iwa.core.utils import configure_logger
+from iwa.plugins.olas.constants import OLAS_TRADER_STAKING_CONTRACTS
+from iwa.plugins.olas.contracts.staking import StakingContract
+
+# Configure logger to avoid noise during execution
+logger = configure_logger()
+logging.getLogger("web3").setLevel(logging.WARNING)
+logging.getLogger("urllib3").setLevel(logging.WARNING)
+
+
+def parse_args():
+    """Parse command line arguments."""
+    parser = argparse.ArgumentParser(description="List Olas staking contracts.")
+    parser.add_argument(
+        "--sort",
+        type=str,
+        choices=["name", "rewards", "epoch", "slots", "olas"],
+        default="name",
+        help="Sort by field (default: name)",
+    )
+    return parser.parse_args()
+
+
+def fetch_contract_data(chain_name):
+    """Fetch data for all contracts."""
+    contracts_map = OLAS_TRADER_STAKING_CONTRACTS.get(chain_name, {})
+    contract_data = []
+
+    for name, address in track(contracts_map.items(), description="Fetching contract data..."):
+        try:
+            contract = StakingContract(address, chain_name=chain_name)
+
+            # Needed Olas (Bond + Deposit)
+            needed_olas = (contract.min_staking_deposit * 2) / 1e18
+
+            # Slots
+            service_ids = contract.get_service_ids()
+            max_slots = contract.max_num_services
+
+            # Rewards & Balance
+            rewards_olas = contract.available_rewards / 1e18
+            balance_olas = contract.balance / 1e18
+
+            contract_data.append(
+                {
+                    "name": name,
+                    "needed_olas": needed_olas,
+                    "occupied_slots": len(service_ids),
+                    "max_slots": max_slots,
+                    "free_slots": max_slots - len(service_ids),
+                    "rewards_olas": rewards_olas,
+                    "balance_olas": balance_olas,
+                    "epoch_end": contract.get_next_epoch_start(),
+                    "error": None,
+                }
+            )
+        except Exception as e:
+            contract_data.append({"name": name, "error": str(e)})
+
+    return contract_data
+
+
+def sort_contract_data(contract_data, sort_criterion):
+    """Sort contract data based on criterion."""
+    if sort_criterion == "name":
+        contract_data.sort(key=lambda x: x["name"])
+    elif sort_criterion == "rewards":
+        contract_data.sort(
+            key=lambda x: (x.get("rewards_olas", -1) if not x.get("error") else -1), reverse=True
+        )
+    elif sort_criterion == "epoch":
+        safe_max = 32503680000
+        contract_data.sort(key=lambda x: safe_max if x.get("error") else x["epoch_end"].timestamp())
+    elif sort_criterion == "slots":
+        contract_data.sort(
+            key=lambda x: (x.get("free_slots", -1) if not x.get("error") else -1), reverse=True
+        )
+    elif sort_criterion == "olas":
+        contract_data.sort(
+            key=lambda x: (
+                x.get("needed_olas", float("inf")) if not x.get("error") else float("inf")
+            )
+        )
+
+
+def print_table(console, contract_data, chain_name, sort_criterion):
+    """Print the contracts table."""
+    table = Table(title=f"Olas Staking Contracts ({chain_name}) - Sorted by: {sort_criterion}")
+    table.add_column("Contract Name", style="cyan", no_wrap=True)
+    table.add_column("Necessary Olas", justify="right", style="green")
+    table.add_column("Slots (Free/Max)", justify="right", style="magenta")
+    table.add_column("Available Rewards", justify="right", style="yellow")
+    table.add_column("Contract Balance", justify="right", style="blue")
+    table.add_column("Epoch End (UTC)", justify="right", style="white")
+
+    for item in contract_data:
+        if item.get("error"):
+            table.add_row(item["name"], "ERROR", "-", "-", "-", item["error"])
+        else:
+            table.add_row(
+                item["name"],
+                f"{item['needed_olas']:,.0f} OLAS",
+                f"{item['free_slots']}/{item['max_slots']}",
+                f"{item['rewards_olas']:,.2f} OLAS",
+                f"{item['balance_olas']:,.2f} OLAS",
+                item["epoch_end"].strftime("%Y-%m-%d %H:%M:%S"),
+            )
+    console.print(table)
+
+
+def main():
+    """Run the contracts list tool."""
+    args = parse_args()
+    console = Console()
+    chain_name = "gnosis"
+
+    if chain_name not in OLAS_TRADER_STAKING_CONTRACTS:
+        console.print(f"[red]No contracts found for chain {chain_name}[/red]")
+        return
+
+    contract_data = fetch_contract_data(chain_name)
+    sort_contract_data(contract_data, args.sort)
+    print_table(console, contract_data, chain_name, args.sort)
+
+
+if __name__ == "__main__":
+    main()

iwa/tools/release.py

@@ -3,6 +3,7 @@
 
 Usage: python release.py <version>
 """
+
 import argparse
 import subprocess  # nosec: B404
 import sys
@@ -18,7 +19,7 @@ def run(cmd: str, check: bool = True, capture: bool = False) -> str:
             check=check,
             text=True,
             stdout=subprocess.PIPE if capture else None,
-            stderr=subprocess.PIPE if capture else None
+            stderr=subprocess.PIPE if capture else None,
         )
         return result.stdout.strip() if capture else ""
     except subprocess.CalledProcessError as e:
@@ -26,27 +27,31 @@ def run(cmd: str, check: bool = True, capture: bool = False) -> str:
             print(f"Error output: {e.stderr}")
         sys.exit(e.returncode)
 
+
 def error(msg: str) -> NoReturn:
     """Print error and exit."""
     print(f"❌ Error: {msg}")
     sys.exit(1)
 
+
 def info(msg: str) -> None:
     """Print info message."""
     print(f"🚀 {msg}")
 
+
 def confirm(question: str) -> bool:
     """Ask for user confirmation."""
     while True:
         try:
             choice = input(f"{question} [y/N] ").lower()
-            if not choice or choice == 'n':
+            if not choice or choice == "n":
                 return False
-            if choice == 'y':
+            if choice == "y":
                 return True
         except EOFError:
             return False
 
+
 def main() -> None:
     """Execute the release process."""
     parser = argparse.ArgumentParser(description="Create a new release")
@@ -107,5 +112,6 @@ def main() -> None:
         run(f"git push {check_url} {tag}")
         print(f"✅ Release {tag} triggered! Check GitHub Actions.")
 
+
 if __name__ == "__main__":
     main()

iwa/tools/reset_env.py

@@ -13,7 +13,7 @@ import sys
 import yaml
 
 from iwa.core.constants import CONFIG_PATH, WALLET_PATH
-from iwa.core.settings import settings
+from iwa.core.models import Config
 
 
 def _reset_tenderly(profile: int) -> None:
@@ -97,7 +97,7 @@ def _clean_wallet_accounts() -> None:
 
 def main():
     """Reset the environment by clearing networks, services, and accounts."""
-    profile = settings.tenderly_profile
+    profile = Config().core.tenderly_profile
     print(f"Detected Tenderly profile: {profile}")
 
     _reset_tenderly(profile)

iwa/tools/reset_tenderly.py

@@ -10,25 +10,25 @@ import sys
 from typing import List, Optional, Tuple
 
 import requests
+from dotenv import load_dotenv
 from web3 import Web3
 
 from iwa.core.constants import SECRETS_PATH, get_tenderly_config_path
 from iwa.core.keys import KeyStorage
-from iwa.core.models import TenderlyConfig
-from iwa.core.settings import settings
+from iwa.core.models import Config, TenderlyConfig
 
+# Load secrets.env for local development
+if SECRETS_PATH.exists():
+    load_dotenv(SECRETS_PATH, override=True)
 
-def get_tenderly_credentials() -> Tuple[Optional[str], Optional[str], Optional[str]]:
-    """Get Tenderly credentials from settings (based on current profile)."""
-    return (
-        settings.tenderly_account_slug.get_secret_value()
-        if settings.tenderly_account_slug
-        else None,
-        settings.tenderly_project_slug.get_secret_value()
-        if settings.tenderly_project_slug
-        else None,
-        settings.tenderly_access_key.get_secret_value() if settings.tenderly_access_key else None,
-    )
+
+def get_tenderly_credentials(profile: int) -> Tuple[Optional[str], Optional[str], Optional[str]]:
+    """Get Tenderly credentials dynamically based on profile."""
+    # Secrets are still in env, keyed by profile
+    account = os.getenv(f"tenderly_account_slug_{profile}")
+    project = os.getenv(f"tenderly_project_slug_{profile}")
+    access_key = os.getenv(f"tenderly_access_key_{profile}")
+    return account, project, access_key
 
 
 def _generate_default_config() -> TenderlyConfig:
@@ -38,6 +38,7 @@ def _generate_default_config() -> TenderlyConfig:
 
     vnets = {}
     chains = SupportedChains()
+    config = Config()
 
     for chain_name, chain in [
         ("gnosis", chains.gnosis),
@@ -53,7 +54,7 @@ def _generate_default_config() -> TenderlyConfig:
                 TokenAmount(
                     address=str(olas_address),
                     symbol="OLAS",
-                    amount_eth=settings.tenderly_olas_funds,
+                    amount_eth=config.core.tenderly_olas_funds,
                 )
             )
 
@@ -61,7 +62,7 @@ def _generate_default_config() -> TenderlyConfig:
             chain_id=chain.chain_id,
             funds_requirements={
                 "all": FundRequirements(
-                    native_eth=settings.tenderly_native_funds,
+                    native_eth=config.core.tenderly_native_funds,
                     tokens=tokens,
                 )
             },
@@ -295,11 +296,12 @@ def _fund_vnet_accounts(vnet, keys) -> None:
 
 
 def main() -> None:
-    """Main - uses tenderly_profile from settings."""
-    profile = settings.tenderly_profile
+    """Main - uses tenderly_profile from Config."""
+    config = Config()
+    profile = config.core.tenderly_profile
     print(f"Recreating Tenderly Networks (Profile {profile})")
 
-    account_slug, project_slug, tenderly_access_key = get_tenderly_credentials()
+    account_slug, project_slug, tenderly_access_key = get_tenderly_credentials(profile)
 
     if not account_slug or not project_slug or not tenderly_access_key:
         print(f"Missing Tenderly environment variables for profile {profile}")
@@ -350,13 +352,13 @@ if __name__ == "__main__":  # pragma: no cover
     os.environ["TENDERLY_PROFILE"] = str(args.profile)
 
     # Reset the singleton to reload with new env
-    from iwa.core.settings import Settings
+    from iwa.core.secrets import Secrets
 
-    Settings._instance = None  # type: ignore
+    Secrets._instance = None  # type: ignore
 
-    # Reimport settings to get fresh instance
-    if "iwa.core.settings" in sys.modules:
-        del sys.modules["iwa.core.settings"]
-    from iwa.core.settings import settings  # noqa: F401
+    # Reimport secrets to get fresh instance
+    if "iwa.core.secrets" in sys.modules:
+        del sys.modules["iwa.core.secrets"]
+    from iwa.core.secrets import secrets  # noqa: F401
 
     main()

iwa/tools/wallet_check.py

@@ -0,0 +1,150 @@
+"""Wallet integrity check utility."""
+
+import sys
+
+from eth_account import Account
+
+from iwa.core.keys import KeyStorage
+from iwa.core.mnemonic import EncryptedMnemonic
+from iwa.core.models import StoredSafeAccount
+from iwa.core.secrets import secrets
+from iwa.core.utils import configure_logger
+
+# Configure logger to be quiet for this tool unless error
+logger = configure_logger()
+
+
+def _check_accounts(storage: KeyStorage) -> bool:
+    """Verify that all EOAs in the wallet can be decrypted.
+
+    Args:
+        storage: The KeyStorage instance.
+
+    Returns:
+        bool: True if all EOAs were verified successfully.
+
+    """
+    if not storage.accounts:
+        print("⚠️  No accounts found in wallet.json.")
+        return True
+
+    success_count = 0
+    fail_count = 0
+    safe_count = 0
+
+    # Ensure we sort by tag for consistent output
+    sorted_accounts = sorted(storage.accounts.values(), key=lambda x: x.tag if x.tag else "")
+
+    for account in sorted_accounts:
+        if isinstance(account, StoredSafeAccount):
+            print(
+                f"🔹 [Safe]  {account.address} (tag: {account.tag or 'none'}) "
+                "- Skipped (Contract Wallet)"
+            )
+            safe_count += 1
+            continue
+
+        try:
+            # Decrypt using the password from secrets.env
+            priv_key = account.decrypt_private_key()
+
+            # Verify address matches
+            derived_acct = Account.from_key(priv_key)
+
+            if derived_acct.address.lower() == account.address.lower():
+                print(f"✅ [EOA]   {account.address} (tag: {account.tag or 'none'}) - OK")
+                success_count += 1
+            else:
+                print(
+                    f"❌ [EOA]   {account.address} (tag: {account.tag or 'none'}) "
+                    "- ADDRESS MISMATCH!"
+                )
+                print(f"    Expected: {account.address}")
+                print(f"    Derived:  {derived_acct.address}")
+                fail_count += 1
+        except Exception as e:
+            print(
+                f"❌ [EOA]   {account.address} (tag: {account.tag or 'none'}) - DECRYPTION FAILED!"
+            )
+            print(f"    Error: {e}")
+            fail_count += 1
+
+    print("\n" + "-" * 40)
+    print(f"Accounts Verified: {success_count}")
+    print(f"Accounts Failed:   {fail_count}")
+    if safe_count:
+        print(f"Safes Skipped:     {safe_count}")
+
+    return fail_count == 0
+
+
+def _check_mnemonic(storage: KeyStorage) -> bool:
+    """Verify that the encrypted mnemonic can be decrypted.
+
+    Args:
+        storage: The KeyStorage instance.
+
+    Returns:
+        bool: True if the mnemonic was verified successfully.
+
+    """
+    print("\n🔍 Checking Mnemonic...")
+    if not storage.encrypted_mnemonic:
+        print("⚠️  No encrypted mnemonic found in wallet.json.")
+        return True
+
+    try:
+        # Instantiate EncryptedMnemonic from the dict stored in KeyStorage
+        enc_mnemonic = EncryptedMnemonic(**storage.encrypted_mnemonic)
+
+        # Get password (checked implicitly by KeyStorage init)
+        password = secrets.wallet_password.get_secret_value()
+
+        # Attempt decryption
+        mnemonic_text = enc_mnemonic.decrypt(password)
+
+        if mnemonic_text:
+            # Basic validation (e.g. check word count) - explicit
+            word_count = len(mnemonic_text.split())
+            if word_count in [12, 15, 18, 21, 24]:
+                print(f"✅ [Mnemonic] Decryption successful ({word_count} words).")
+                return True
+            print(f"⚠️  [Mnemonic] Decryption successful but unusual word count: {word_count}")
+            return True
+
+        print("❌ [Mnemonic] Decrypted to empty string.")
+        return False
+
+    except Exception as e:
+        print(f"❌ [Mnemonic] Decryption FAILED! Error: {e}")
+        return False
+
+
+def check_wallet() -> None:
+    """Verify that all EOAs in the wallet can be decrypted and mnemonic is valid."""
+    print("🔍 Verifying wallet integrity...")
+    print("This process checks if the WALLET_PASSWORD in secrets.env can decrypt all accounts.")
+    print()
+
+    try:
+        # KeyStorage loads WALLET_PATH and uses secrets.wallet_password by default
+        storage = KeyStorage()
+    except Exception as e:
+        print(f"❌ Critical Error: Could not initialize KeyStorage. {e}")
+        sys.exit(1)
+
+    accounts_ok = _check_accounts(storage)
+    mnemonic_ok = _check_mnemonic(storage)
+
+    print("\n" + "=" * 40)
+    print("REPORT SUMMARY")
+    if accounts_ok and mnemonic_ok:
+        print("✨ All checks passed! Wallet is healthy.")
+        sys.exit(0)
+    else:
+        print("❌ Wallet check FAILED. See errors above.")
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    check_wallet()

iwa/web/dependencies.py

@@ -19,11 +19,11 @@ api_key_header = APIKeyHeader(name="X-API-Key", auto_error=False)
 
 
 def _get_webui_password() -> Optional[str]:
-    """Get WEBUI_PASSWORD from settings (lazy load to ensure secrets.env is loaded)."""
-    from iwa.core.settings import settings
+    """Get WEBUI_PASSWORD from secrets (lazy load to ensure secrets.env is loaded)."""
+    from iwa.core.secrets import secrets
 
-    if hasattr(settings, "webui_password") and settings.webui_password:
-        return settings.webui_password.get_secret_value()
+    if hasattr(secrets, "webui_password") and secrets.webui_password:
+        return secrets.webui_password.get_secret_value()
     return None
 
 

iwa/web/routers/state.py

@@ -30,6 +30,7 @@ def get_state(auth: bool = Depends(verify_auth)):
         "tokens": tokens,
         "native_currencies": native_currencies,
         "default_chain": "gnosis",
+        "testing": ChainInterfaces().gnosis.is_tenderly,
     }