iwa 0.0.2__tar.gz → 0.0.10__tar.gz

{iwa-0.0.2/src/iwa.egg-info → iwa-0.0.10}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: iwa
-Version: 0.0.2
+Version: 0.0.10
 Summary: A secure, modular, and plugin-based framework for crypto agents and ops
 Requires-Python: <4.0,>=3.12
 Description-Content-Type: text/markdown

{iwa-0.0.2 → iwa-0.0.10}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "iwa"
-version = "0.0.2"
+version = "0.0.10"
 description = "A secure, modular, and plugin-based framework for crypto agents and ops"
 readme = "README.md"
 requires-python = ">=3.12,<4.0"
@@ -71,7 +71,7 @@ where = ["src"]
 
 [tool.ruff]
 line-length = 100
-target-version = "0.0.2"
+target-version = "0.0.10"
 fix = true
 
 [tool.ruff.lint]

{iwa-0.0.2 → iwa-0.0.10}/src/iwa/core/chain/interface.py

@@ -1,5 +1,6 @@
 """ChainInterface class for blockchain interactions."""
 
+import threading
 import time
 from typing import Callable, Dict, Optional, Tuple, TypeVar, Union
 
@@ -45,6 +46,7 @@ class ChainInterface:
             )
 
         self._initial_block = 0
+        self._rotation_lock = threading.Lock()
         self._init_web3()
 
     @property
@@ -154,18 +156,6 @@ class ChainInterface:
         print("╚══════════════════════════════════════════════════╝")
         print("")
 
-    def _init_web3(self):
-        """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}))
-
-        # 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."""
         err_text = str(error).lower()
@@ -269,19 +259,36 @@ class ChainInterface:
 
     def rotate_rpc(self) -> bool:
         """Rotate to the next available RPC."""
-        if not self.chain.rpcs or len(self.chain.rpcs) <= 1:
-            return False
+        with self._rotation_lock:
+            if not self.chain.rpcs or len(self.chain.rpcs) <= 1:
+                return False
+
+            # Simple Round Robin rotation
+            self._current_rpc_index = (self._current_rpc_index + 1) % len(self.chain.rpcs)
+            # Internal call to _init_web3 already expects to be under lock if called from here,
+            # but _init_web3 itself doesn't have a lock. Let's make it consistent.
+            self._init_web3_under_lock()
+
+            logger.info(
+                f"Rotated RPC for {self.chain.name} to index {self._current_rpc_index}: {self.chain.rpcs[self._current_rpc_index]}"
+            )
+            return True
 
-        # 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()
+    def _init_web3(self):
+        """Initialize Web3 with current RPC (thread-safe)."""
+        with self._rotation_lock:
+            self._init_web3_under_lock()
 
-        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 _init_web3_under_lock(self):
+        """Internal non-thread-safe web3 initialization."""
+        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}))
+
+        # Use duck typing to check if current web3 is a RateLimitedWeb3 wrapper
+        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 check_rpc_health(self) -> bool:
         """Check if the current RPC is healthy."""

{iwa-0.0.2 → iwa-0.0.10}/src/iwa/core/chain/models.py

@@ -78,13 +78,11 @@ class Gnosis(SupportedChain):
         if not self.rpcs and secrets.gnosis_rpc:
             self.rpcs = secrets.gnosis_rpc.get_secret_value().split(",")
 
-        # Defensive: ensure no comma-separated strings in list
+        # Defensive: ensure no comma-separated strings and NO quotes in list
         new_rpcs = []
         for rpc in self.rpcs:
-            if "," in rpc:
-                new_rpcs.extend([r.strip() for r in rpc.split(",") if r.strip()])
-            else:
-                new_rpcs.append(rpc)
+            parts = [r.strip().strip("'\"") for r in rpc.split(",") if r.strip()]
+            new_rpcs.extend(parts)
         self.rpcs = new_rpcs
 
 
@@ -107,13 +105,11 @@ class Ethereum(SupportedChain):
         if not self.rpcs and secrets.ethereum_rpc:
             self.rpcs = secrets.ethereum_rpc.get_secret_value().split(",")
 
-        # Defensive: ensure no comma-separated strings in list
+        # Defensive: ensure no comma-separated strings and NO quotes in list
         new_rpcs = []
         for rpc in self.rpcs:
-            if "," in rpc:
-                new_rpcs.extend([r.strip() for r in rpc.split(",") if r.strip()])
-            else:
-                new_rpcs.append(rpc)
+            parts = [r.strip().strip("'\"") for r in rpc.split(",") if r.strip()]
+            new_rpcs.extend(parts)
         self.rpcs = new_rpcs
 
 
@@ -136,13 +132,11 @@ class Base(SupportedChain):
         if not self.rpcs and secrets.base_rpc:
             self.rpcs = secrets.base_rpc.get_secret_value().split(",")
 
-        # Defensive: ensure no comma-separated strings in list
+        # Defensive: ensure no comma-separated strings and NO quotes in list
         new_rpcs = []
         for rpc in self.rpcs:
-            if "," in rpc:
-                new_rpcs.extend([r.strip() for r in rpc.split(",") if r.strip()])
-            else:
-                new_rpcs.append(rpc)
+            parts = [r.strip().strip("'\"") for r in rpc.split(",") if r.strip()]
+            new_rpcs.extend(parts)
         self.rpcs = new_rpcs
 
 

{iwa-0.0.2 → iwa-0.0.10}/src/iwa/core/contracts/contract.py

@@ -190,10 +190,16 @@ class ContractInstance:
             Exception: If the call fails, with decoded error information.
 
         """
-        method = getattr(self.contract.functions, method_name)
         try:
+
+            def do_call():
+                # Re-evaluate self.contract on each retry to get current provider
+                # This is critical for RPC rotation to work correctly
+                method = getattr(self.contract.functions, method_name)
+                return method(*args).call()
+
             return self.chain_interface.with_retry(
-                lambda: method(*args).call(),
+                do_call,
                 operation_name=f"call {method_name} on {self.name}",
             )
         except Exception as e:

{iwa-0.0.2 → iwa-0.0.10}/src/iwa/core/pricing.py

@@ -9,17 +9,19 @@ from loguru import logger
 
 from iwa.core.secrets import secrets
 
+# Global cache shared across all PriceService instances
+_PRICE_CACHE: Dict[str, Dict] = {}
+_CACHE_TTL = timedelta(minutes=30)
+
 
 class PriceService:
     """Service to fetch token prices from CoinGecko."""
 
     BASE_URL = "https://api.coingecko.com/api/v3"
 
-    def __init__(self, cache_ttl_minutes: int = 5):
+    def __init__(self):
         """Initialize PriceService."""
         self.secrets = secrets
-        self.cache: Dict[str, Dict] = {}  # {id_currency: {"price": float, "timestamp": datetime}}
-        self.cache_ttl = timedelta(minutes=cache_ttl_minutes)
         self.api_key = (
             self.secrets.coingecko_api_key.get_secret_value()
             if self.secrets.coingecko_api_key
@@ -39,15 +41,15 @@ class PriceService:
         """
         cache_key = f"{token_id}_{vs_currency}"
 
-        # Check cache
-        if cache_key in self.cache:
-            entry = self.cache[cache_key]
-            if datetime.now() - entry["timestamp"] < self.cache_ttl:
+        # Check global cache
+        if cache_key in _PRICE_CACHE:
+            entry = _PRICE_CACHE[cache_key]
+            if datetime.now() - entry["timestamp"] < _CACHE_TTL:
                 return entry["price"]
 
         price = self._fetch_price_from_api(token_id, vs_currency)
         if price is not None:
-            self.cache[cache_key] = {"price": price, "timestamp": datetime.now()}
+            _PRICE_CACHE[cache_key] = {"price": price, "timestamp": datetime.now()}
         return price
 
     def _fetch_price_from_api(self, token_id: str, vs_currency: str) -> Optional[float]:

{iwa-0.0.2 → iwa-0.0.10}/src/iwa/core/services/safe.py

@@ -11,7 +11,6 @@ from safe_eth.safe.safe_tx import SafeTx
 from iwa.core.constants import ZERO_ADDRESS
 from iwa.core.db import log_transaction
 from iwa.core.models import StoredSafeAccount
-from iwa.core.secrets import secrets
 from iwa.core.utils import (
     get_safe_master_copy_address,
     get_safe_proxy_factory_address,
@@ -99,8 +98,11 @@ class SafeService:
         return owner_addresses
 
     def _get_ethereum_client(self, chain_name: str) -> EthereumClient:
-        rpc_secret = getattr(secrets, f"{chain_name}_rpc")
-        return EthereumClient(rpc_secret.get_secret_value())
+        from iwa.core.chain import ChainInterfaces
+
+        # Use ChainInterface which has proper RPC rotation and parsing
+        chain_interface = ChainInterfaces().get(chain_name)
+        return EthereumClient(chain_interface.chain.rpc)
 
     def _deploy_safe_contract(
         self,
@@ -141,7 +143,7 @@ class SafeService:
                 gas=5_000_000,
                 gas_price=gas_price,
             )
-            return tx_sent.contract_address, tx_sent.tx_hash.hex()
+            return tx_sent.contract_address, f"0x{tx_sent.tx_hash.hex()}"
 
         else:
             # Standard random salt via Safe.create
@@ -153,7 +155,7 @@ class SafeService:
                 threshold=threshold,
                 proxy_factory_address=proxy_factory_address,
             )
-            return create_tx.contract_address, create_tx.tx_hash.hex()
+            return create_tx.contract_address, f"0x{create_tx.tx_hash.hex()}"
 
     def _log_safe_deployment(
         self,
@@ -248,8 +250,11 @@ class SafeService:
                 continue
 
             for chain in account.chains:
-                rpc_secret = getattr(secrets, f"{chain}_rpc")
-                ethereum_client = EthereumClient(rpc_secret.get_secret_value())
+                from iwa.core.chain import ChainInterfaces
+
+                # Use ChainInterface which has proper RPC rotation and parsing
+                chain_interface = ChainInterfaces().get(chain)
+                ethereum_client = EthereumClient(chain_interface.chain.rpc)
 
                 code = ethereum_client.w3.eth.get_code(account.address)
 
@@ -304,7 +309,7 @@ class SafeService:
             # Execute using the first signer
             safe_tx.execute(signer_keys[0])
 
-            return safe_tx.tx_hash.hex()
+            return f"0x{safe_tx.tx_hash.hex()}"
         finally:
             # SECURITY: Overwrite keys with zeros before clearing (best effort)
             for i in range(len(signer_keys)):

{iwa-0.0.2 → iwa-0.0.10}/src/iwa/core/services/transaction.py

@@ -30,7 +30,7 @@ class TransactionService:
         """Sign and send a transaction with retry logic for gas."""
         chain_interface = ChainInterfaces().get(chain_name)
         tx = dict(transaction)
-        max_retries = 3
+        max_retries = 10
 
         if not self._prepare_transaction(tx, signer_address_or_tag, chain_interface):
             return False, {}
@@ -39,7 +39,14 @@ class TransactionService:
             try:
                 signed_txn = self.key_storage.sign_transaction(tx, signer_address_or_tag)
                 txn_hash = chain_interface.web3.eth.send_raw_transaction(signed_txn.raw_transaction)
-                receipt = chain_interface.web3.eth.wait_for_transaction_receipt(txn_hash)
+
+                # Use chain_interface.with_retry for waiting for receipt to handle timeouts/RPC errors
+                def wait_for_receipt(tx_h=txn_hash):
+                    return chain_interface.web3.eth.wait_for_transaction_receipt(tx_h)
+
+                receipt = chain_interface.with_retry(
+                    wait_for_receipt, operation_name="wait_for_receipt"
+                )
 
                 if receipt and getattr(receipt, "status", None) == 1:
                     signer_account = self.account_service.resolve_account(signer_address_or_tag)
@@ -89,7 +96,9 @@ class TransactionService:
             )
             current_gas = int(tx.get("gas", 30_000))
             tx["gas"] = int(current_gas * 1.5)
-            time.sleep(0.5 * attempt)
+            tx["gas"] = int(current_gas * 1.5)
+            # Exponential backoff for gas errors
+            time.sleep(min(2**attempt, 30))
             return True
         logger.exception(f"Error sending transaction: {e}")
         return False
@@ -97,9 +106,11 @@ class TransactionService:
     def _handle_generic_error(self, e, chain_interface, attempt, max_retries) -> bool:
         if attempt < max_retries:
             logger.warning(f"Error encountered: {e}. Attempting to rotate RPC...")
+
             if chain_interface.rotate_rpc():
                 logger.info("Retrying with new RPC...")
-                time.sleep(0.5 * attempt)
+                # Exponential backoff
+                time.sleep(min(2**attempt, 30))
                 return True
         logger.exception(f"Unexpected error sending transaction: {e}")
         return False

{iwa-0.0.2 → iwa-0.0.10}/src/iwa/core/utils.py

@@ -38,24 +38,46 @@ def get_safe_proxy_factory_address(target_version: str = "1.4.1") -> str:
     raise ValueError(f"Did not find proxy factory for version {target_version}")
 
 
+def get_tx_hash(receipt: dict) -> str:
+    """Safely extract transaction hash from receipt (handles bytes/str/None)."""
+    if not receipt:
+        return "unknown"
+
+    tx_hash = receipt.get("transactionHash", "")
+    if hasattr(tx_hash, "hex"):
+        return tx_hash.hex()
+    return str(tx_hash) if tx_hash else "unknown"
+
+
 def configure_logger():
     """Configure the logger for the application."""
     if hasattr(configure_logger, "configured"):
         return logger
 
+    import logging
+
     from iwa.core.constants import DATA_DIR
 
+    # Silence noisy third-party loggers (these use stdlib logging, not loguru)
+    logging.getLogger("apscheduler.scheduler").setLevel(logging.WARNING)
+    logging.getLogger("apscheduler.executors.default").setLevel(logging.WARNING)
+    logging.getLogger("httpx").setLevel(logging.WARNING)
+
     logger.remove()
 
     # Ensure data directory exists
     DATA_DIR.mkdir(parents=True, exist_ok=True)
 
+    import sys
+
     logger.add(
         DATA_DIR / "iwa.log",
         rotation="10 MB",
         level="INFO",
         format="{time:YYYY-MM-DD HH:mm:ss.SSS} | {level: <8} | {name}:{function}:{line} - {message}",
     )
+    # Restore console logging (stderr) so logs are visible in docker/systemd/frontend streams
+    logger.add(sys.stderr, level="INFO")
     # Also keep stderr for console if needed, but Textual captures it?
     # Textual usually captures stderr. Writing to file is safer for debugging.
     # Users previous logs show stdout format?

{iwa-0.0.2 → iwa-0.0.10}/src/iwa/plugins/gnosis/safe.py

@@ -8,7 +8,6 @@ from safe_eth.safe import Safe, SafeOperationEnum
 from safe_eth.safe.safe_tx import SafeTx
 
 from iwa.core.models import StoredSafeAccount
-from iwa.core.secrets import secrets
 from iwa.core.utils import configure_logger
 
 logger = configure_logger()
@@ -28,8 +27,10 @@ class SafeMultisig:
         if chain_name.lower() not in normalized_chains:
             raise ValueError(f"Safe account is not deployed on chain: {chain_name}")
 
-        rpc_secret = getattr(secrets, f"{chain_name.lower()}_rpc")
-        ethereum_client = EthereumClient(rpc_secret.get_secret_value())
+        from iwa.core.chain import ChainInterfaces
+
+        chain_interface = ChainInterfaces().get(chain_name.lower())
+        ethereum_client = EthereumClient(chain_interface.chain.rpc)
         self.multisig = Safe(safe_account.address, ethereum_client)
         self.ethereum_client = ethereum_client
 

{iwa-0.0.2 → iwa-0.0.10}/src/iwa/plugins/gnosis/tests/test_safe.py

@@ -11,9 +11,8 @@ from iwa.plugins.gnosis.safe import SafeMultisig
 @pytest.fixture
 def mock_settings():
     """Mock settings."""
-    with patch("iwa.plugins.gnosis.safe.secrets") as mock:
-        mock.gnosis_rpc.get_secret_value.return_value = "http://rpc"
-        yield mock
+    # secrets is no longer used in this module, so we don't need to patch it here
+    yield None
 
 
 @pytest.fixture
@@ -41,10 +40,13 @@ def safe_account():
 
 def test_init(safe_account, mock_settings, mock_safe_eth):
     """Test initialization."""
-    ms = SafeMultisig(safe_account, "gnosis")
-    assert ms.multisig is not None
-    mock_safe_eth[0].assert_called_with("http://rpc")  # EthereumClient init
-    mock_safe_eth[1].assert_called()  # Safe init
+    with patch("iwa.core.chain.ChainInterfaces") as mock_ci_cls:
+        mock_ci = mock_ci_cls.return_value
+        mock_ci.get.return_value.chain.rpc = "http://rpc"
+        ms = SafeMultisig(safe_account, "gnosis")
+        assert ms.multisig is not None
+        mock_safe_eth[0].assert_called_with("http://rpc")  # EthereumClient init
+        mock_safe_eth[1].assert_called()  # Safe init
 
 
 def test_init_invalid_chain(safe_account, mock_settings, mock_safe_eth):

{iwa-0.0.2 → iwa-0.0.10}/src/iwa/plugins/olas/contracts/service.py

@@ -64,10 +64,10 @@ class ServiceRegistryContract(ContractInstance):
         """Get the token address for a service."""
         return self.call("token", service_id)
 
-    def get_agent_params(self, service_id: int, agent_id: int) -> Dict:
-        """Get agent params (slots, bond) for a service."""
-        (slots, bond) = self.call("getAgentParams", service_id, agent_id)
-        return {"slots": slots, "bond": bond}
+    def get_agent_params(self, service_id: int) -> list:
+        """Get agent params (slots, bond) for all agents in a service."""
+        num_ids, params = self.call("getAgentParams", service_id)
+        return [{"slots": p[0], "bond": p[1]} for p in params]
 
     def prepare_approve_tx(
         self,

{iwa-0.0.2 → iwa-0.0.10}/src/iwa/plugins/olas/contracts/staking.py

@@ -30,20 +30,19 @@ The staking contract checks that:
 4. Agent bond was deposited during service registration
 """
 
-import logging
 import math
 import time
 from datetime import datetime, timezone
 from enum import Enum
 from typing import Dict, List, Optional, Union
 
+from loguru import logger
+
 from iwa.core.contracts.contract import ContractInstance
 from iwa.core.types import EthereumAddress
 from iwa.plugins.olas.contracts.activity_checker import ActivityCheckerContract
 from iwa.plugins.olas.contracts.base import OLAS_ABI_PATH
 
-logger = logging.getLogger(__name__)
-
 
 class StakingState(Enum):
     """Enum representing the staking state of a service."""

{iwa-0.0.2 → iwa-0.0.10}/src/iwa/plugins/olas/plugin.py

@@ -48,8 +48,12 @@ class OlasPlugin(Plugin):
         """Create a new Olas service"""
         wallet = Wallet()
         manager = ServiceManager(wallet)
-        # Note: Manager logic currently depends on internal config state which might need setup
-        manager.create(chain_name, owner, token, bond)
+        manager.create(
+            chain_name=chain_name,
+            service_owner_address_or_tag=owner,
+            token_address_or_tag=token,
+            bond_amount_wei=bond,
+        )
 
     def _get_safe_signers(self, safe_address: str, chain_name: str) -> tuple:
         """Query Safe signers on-chain.
@@ -65,13 +69,16 @@ class OlasPlugin(Plugin):
             from safe_eth.eth import EthereumClient
             from safe_eth.safe import Safe
 
-            from iwa.core.secrets import secrets
+            from iwa.core.chain import ChainInterfaces
 
-            rpc_secret = getattr(secrets, f"{chain_name}_rpc", None)
-            if not rpc_secret:
-                return None, None  # Can't verify, skip
+            try:
+                chain_interface = ChainInterfaces().get(chain_name)
+                if not chain_interface.chain.rpcs:
+                    return None, None
+            except ValueError:
+                return None, None  # Chain not supported/configured
 
-            ethereum_client = EthereumClient(rpc_secret.get_secret_value())
+            ethereum_client = EthereumClient(chain_interface.chain.rpc)
             safe = Safe(safe_address, ethereum_client)
             owners = safe.retrieve_owners()
             return owners, True