iwa 0.0.61__tar.gz → 0.0.62__tar.gz

{iwa-0.0.61/src/iwa.egg-info → iwa-0.0.62}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: iwa
-Version: 0.0.61
+Version: 0.0.62
 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.61 → iwa-0.0.62}/pyproject.toml

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

{iwa-0.0.61 → iwa-0.0.62}/src/iwa/core/chain/interface.py

@@ -285,11 +285,15 @@ class ChainInterface:
 
     # -- ChainList enrichment ----------------------------------------------
 
-    MAX_RPCS = 10  # Cap total RPCs per chain
+    MAX_RPCS = 20  # Cap total RPCs per chain
 
     def _enrich_rpcs_from_chainlist(self) -> None:
         """Add validated public RPCs from ChainList to the rotation pool."""
         if len(self.chain.rpcs) >= self.MAX_RPCS:
+            logger.debug(
+                f"{self.chain.name}: skipping ChainList enrichment "
+                f"(already have {len(self.chain.rpcs)} RPCs)"
+            )
             return
 
         try:
@@ -354,35 +358,45 @@ class ChainInterface:
 
         if should_rotate:
             failed_index = self._current_rpc_index
+            failed_rpc = sanitize_rpc_url(self.chain.rpcs[failed_index]) if self.chain.rpcs else "?"
 
             # Apply per-RPC backoff so smart rotation skips this RPC.
             if result["is_quota_exceeded"]:
-                error_type = "quota exceeded"
-                self._mark_rpc_backoff(failed_index, self.QUOTA_EXCEEDED_BACKOFF)
+                error_type = "QUOTA"
+                backoff = self.QUOTA_EXCEEDED_BACKOFF
+                self._mark_rpc_backoff(failed_index, backoff)
             elif result["is_rate_limit"]:
-                error_type = "rate limit"
-                self._mark_rpc_backoff(failed_index, self.RATE_LIMIT_BACKOFF)
+                error_type = "RATE_LIMIT"
+                backoff = self.RATE_LIMIT_BACKOFF
+                self._mark_rpc_backoff(failed_index, backoff)
                 # Brief global backoff so other threads don't immediately flood
                 # the same (now backed-off) RPC before rotation takes effect.
                 self._rate_limiter.trigger_backoff(seconds=2.0)
             else:
-                error_type = "connection"
-                self._mark_rpc_backoff(failed_index, self.CONNECTION_ERROR_BACKOFF)
+                error_type = "CONNECTION"
+                backoff = self.CONNECTION_ERROR_BACKOFF
+                self._mark_rpc_backoff(failed_index, backoff)
+
+            # Count healthy RPCs for visibility
+            healthy_count = sum(1 for i in range(len(self.chain.rpcs)) if self._is_rpc_healthy(i))
+            total_rpcs = len(self.chain.rpcs) if self.chain.rpcs else 0
 
             logger.warning(
-                f"RPC {error_type} error on {self.chain.name} "
-                f"(RPC #{failed_index}): {error}"
+                f"[{self.chain.name}] RPC #{failed_index} {error_type} → "
+                f"backoff {int(backoff)}s ({healthy_count}/{total_rpcs} healthy) | "
+                f"{failed_rpc}: {str(error)[:100]}"
             )
 
             if self.rotate_rpc():
                 result["rotated"] = True
                 result["should_retry"] = True
-                logger.info(f"Rotated to RPC #{self._current_rpc_index} for {self.chain.name}")
+                new_rpc = sanitize_rpc_url(self.chain.rpcs[self._current_rpc_index])
+                logger.info(f"[{self.chain.name}] Rotated to RPC #{self._current_rpc_index}: {new_rpc}")
             else:
                 # Rotation skipped (cooldown or single RPC) - still allow retry
                 result["should_retry"] = True
-                logger.info(
-                    f"RPC rotation skipped, retrying with current RPC #{self._current_rpc_index}"
+                logger.debug(
+                    f"[{self.chain.name}] Rotation skipped (cooldown), retrying RPC #{self._current_rpc_index}"
                 )
 
         elif result["is_server_error"]:

{iwa-0.0.61 → iwa-0.0.62}/src/iwa/core/services/safe_executor.py

@@ -39,6 +39,10 @@ class SafeTransactionExecutor:
     MAX_GAS_MULTIPLIER = 10  # Hard cap: never exceed 10x original estimate
     DEFAULT_FALLBACK_GAS = 500_000  # Fallback when estimation fails
 
+    # Fee bumping for "max fee per gas less than block base fee" errors
+    FEE_BUMP_PERCENTAGE = 1.30  # 30% bump per retry on fee errors
+    MAX_FEE_BUMP_FACTOR = 3.0  # Cap: never bump more than 3x original
+
     def __init__(
         self,
         chain_interface: "ChainInterface",
@@ -76,6 +80,7 @@ class SafeTransactionExecutor:
         last_error = None
         current_gas = safe_tx.safe_tx_gas
         base_estimate = current_gas if current_gas > 0 else 0
+        fee_bump_factor = 1.0  # Multiplier for EIP-1559 fees, increases on fee errors
 
         for attempt in range(self.max_retries + 1):
             SAFE_TX_STATS["total_attempts"] += 1
@@ -89,6 +94,7 @@ class SafeTransactionExecutor:
                     attempt,
                     current_gas,
                     base_estimate,
+                    fee_bump_factor,
                 )
 
                 # Check receipt
@@ -106,7 +112,7 @@ class SafeTransactionExecutor:
                 raise ValueError("Transaction reverted on-chain")
 
             except Exception as e:
-                updated_tx, should_retry = self._handle_execution_failure(
+                updated_tx, should_retry, is_fee_error = self._handle_execution_failure(
                     e, safe_address, safe_tx, attempt, operation_name
                 )
                 last_error = e
@@ -115,7 +121,12 @@ class SafeTransactionExecutor:
 
                 # Update gas/nonce for next loop if needed
                 safe_tx = updated_tx
-                # If gas error, gas is recalculated in next _execute_attempt via fresh estimation
+
+                # Bump fee multiplier on fee-related errors (base fee > max fee)
+                if is_fee_error and fee_bump_factor < self.MAX_FEE_BUMP_FACTOR:
+                    fee_bump_factor *= self.FEE_BUMP_PERCENTAGE
+                    fee_bump_factor = min(fee_bump_factor, self.MAX_FEE_BUMP_FACTOR)
+                    logger.info(f"[{operation_name}] Fee bump factor increased to {fee_bump_factor:.2f}x")
 
                 delay = self.DEFAULT_RETRY_DELAY * (2**attempt)
                 time.sleep(delay)
@@ -131,6 +142,7 @@ class SafeTransactionExecutor:
         attempt,
         current_gas,
         base_estimate,
+        fee_bump_factor: float = 1.0,
     ) -> str:
         """Prepare client, estimate gas, simulate, and execute."""
         # 1. (Re)Create Safe client
@@ -171,24 +183,11 @@ class SafeTransactionExecutor:
         signatures_backup = safe_tx.signatures
 
         try:
-            # Always pass the first signer key as the executor (gas payer).
-            # Note: This method does NOT re-sign the Safe hash if signatures are already present.
-            # Use EIP-1559 'FAST' to ensure adequate priority fee (fixes Gnosis FeeTooLow)
-            result = safe_tx.execute(signer_keys[0], eip1559_speed=TxSpeed.FAST)
-
-            # Handle both tuple return (tx_hash, tx) and bytes return
-            if isinstance(result, tuple):
-                tx_hash_bytes = result[0]
-            else:
-                tx_hash_bytes = result
-
-            # Handle both bytes and hex string returns
-            if isinstance(tx_hash_bytes, bytes):
-                return f"0x{tx_hash_bytes.hex()}"
-            elif isinstance(tx_hash_bytes, str):
-                return tx_hash_bytes if tx_hash_bytes.startswith("0x") else f"0x{tx_hash_bytes}"
-            else:
-                return str(tx_hash_bytes)
+            # Execute with appropriate gas pricing
+            result = self._execute_with_gas_pricing(
+                safe_tx, signer_keys[0], fee_bump_factor, operation_name
+            )
+            return self._extract_tx_hash(result)
 
         finally:
             # Restore signatures for next attempt if needed
@@ -196,6 +195,39 @@ class SafeTransactionExecutor:
             if safe_tx.signatures != signatures_backup:
                 safe_tx.signatures = signatures_backup
 
+    def _execute_with_gas_pricing(
+        self, safe_tx: SafeTx, signer_key: str, fee_bump_factor: float, operation_name: str
+    ):
+        """Execute transaction with appropriate gas pricing strategy.
+
+        If fee_bump_factor > 1.0, calculates a bumped gas price to overcome
+        base fee volatility. Otherwise uses EIP-1559 FAST speed.
+        """
+        if fee_bump_factor > 1.0:
+            bumped_gas_price = self._calculate_bumped_gas_price(fee_bump_factor)
+            if bumped_gas_price:
+                logger.debug(
+                    f"[{operation_name}] Using bumped gas price: {bumped_gas_price} wei "
+                    f"(factor: {fee_bump_factor:.2f}x)"
+                )
+                return safe_tx.execute(signer_key, tx_gas_price=bumped_gas_price)
+            # Fallback to FAST if calculation fails
+            return safe_tx.execute(signer_key, eip1559_speed=TxSpeed.FAST)
+        # Default: use EIP-1559 'FAST' speed
+        return safe_tx.execute(signer_key, eip1559_speed=TxSpeed.FAST)
+
+    def _extract_tx_hash(self, result) -> str:
+        """Extract transaction hash from execute() result."""
+        # Handle both tuple return (tx_hash, tx) and bytes return
+        tx_hash_bytes = result[0] if isinstance(result, tuple) else result
+
+        # Handle both bytes and hex string returns
+        if isinstance(tx_hash_bytes, bytes):
+            return f"0x{tx_hash_bytes.hex()}"
+        if isinstance(tx_hash_bytes, str):
+            return tx_hash_bytes if tx_hash_bytes.startswith("0x") else f"0x{tx_hash_bytes}"
+        return str(tx_hash_bytes)
+
     def _check_receipt_status(self, receipt) -> bool:
         """Check if receipt has successful status."""
         status = getattr(receipt, "status", None)
@@ -210,14 +242,20 @@ class SafeTransactionExecutor:
         safe_tx: SafeTx,
         attempt: int,
         operation_name: str,
-    ) -> Tuple[SafeTx, bool]:
-        """Handle execution failure and determine next steps."""
+    ) -> Tuple[SafeTx, bool, bool]:
+        """Handle execution failure and determine next steps.
+
+        Returns:
+            Tuple of (updated_safe_tx, should_retry, is_fee_error)
+
+        """
         classification = self._classify_error(error)
+        is_fee_error = classification["is_fee_error"]
 
         if attempt >= self.max_retries:
             SAFE_TX_STATS["final_failures"] += 1
             logger.error(f"[{operation_name}] Failed after {attempt + 1} attempts: {error}")
-            return safe_tx, False
+            return safe_tx, False, is_fee_error
 
         strategy = "retry"
         safe = self._recreate_safe_client(safe_address)
@@ -231,13 +269,16 @@ class SafeTransactionExecutor:
             SAFE_TX_STATS["rpc_rotations"] += 1
             result = self.chain_interface._handle_rpc_error(error)
             if not result["should_retry"]:
-                return safe_tx, False
+                return safe_tx, False, is_fee_error
+        elif is_fee_error:
+            strategy = "fee bump"
+            SAFE_TX_STATS["gas_retries"] += 1
         elif classification["is_gas_error"]:
             strategy = "gas increase"
-            # Gas increase handled in next attempt loop
+            SAFE_TX_STATS["gas_retries"] += 1
 
         self._log_retry(attempt + 1, error, strategy)
-        return safe_tx, True
+        return safe_tx, True, is_fee_error
 
     def _estimate_safe_tx_gas(self, safe: Safe, safe_tx: SafeTx, base_estimate: int = 0) -> int:
         """Estimate gas for a Safe transaction with buffer and hard cap."""
@@ -320,14 +361,57 @@ class SafeTransactionExecutor:
             error
         ) or self.chain_interface._is_connection_error(error)
 
+        # Fee-specific errors: base fee jumped above our max fee
+        fee_error_signals = [
+            "max fee per gas less than block base fee",
+            "maxfeepergas",
+            "fee too low",
+            "underpriced",
+        ]
+        is_fee_error = any(signal in err_text for signal in fee_error_signals)
+
         return {
             "is_gas_error": any(x in err_text for x in ["gas", "out of gas", "intrinsic"]),
+            "is_fee_error": is_fee_error,
             "is_nonce_error": self._is_nonce_error(error),
             "is_rpc_error": is_rpc,
             "is_revert": "revert" in err_text or "execution reverted" in err_text,
             "is_signature_error": self._is_signature_error(error),
         }
 
+    def _calculate_bumped_gas_price(self, bump_factor: float) -> Optional[int]:
+        """Calculate a bumped gas price based on current base fee.
+
+        Uses legacy gas price (not EIP-1559) for compatibility with safe-eth-py's
+        tx_gas_price parameter. The bumped price ensures we're above the current
+        base fee even if it's volatile.
+
+        Args:
+            bump_factor: Multiplier to apply to the base fee (e.g., 1.3 = 30% bump)
+
+        Returns:
+            Gas price in wei, or None if calculation fails
+
+        """
+        try:
+            web3 = self.chain_interface.web3
+            latest_block = web3.eth.get_block("latest")
+            base_fee = latest_block.get("baseFeePerGas")
+
+            if base_fee is not None:
+                # EIP-1559 chain: calculate bumped max fee
+                # base_fee * bump_factor * 1.5 (extra buffer) + priority fee
+                priority_fee = max(int(web3.eth.max_priority_fee), 1)
+                bumped_fee = int(base_fee * bump_factor * 1.5) + priority_fee
+                return bumped_fee
+            else:
+                # Legacy chain: bump the gas price directly
+                gas_price = web3.eth.gas_price
+                return int(gas_price * bump_factor)
+        except Exception as e:
+            logger.debug(f"Failed to calculate bumped gas price: {e}")
+            return None
+
     def _decode_revert_reason(self, error: Exception) -> Optional[str]:
         """Attempt to decode the revert reason."""
         import re

{iwa-0.0.61 → iwa-0.0.62/src/iwa.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: iwa
-Version: 0.0.61
+Version: 0.0.62
 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.61 → iwa-0.0.62}/src/tests/test_chainlist_enrichment.py

@@ -343,12 +343,12 @@ class TestEnrichFromChainlist:
 
         chain = MagicMock(spec=SupportedChain)
         chain.name = "TestChain"
-        chain.rpcs = [f"https://rpc{i}.example.com" for i in range(10)]
+        chain.rpcs = [f"https://rpc{i}.example.com" for i in range(20)]
         chain.rpc = "https://rpc0.example.com"
         chain.chain_id = 100
 
         with patch("iwa.core.chainlist.ChainlistRPC") as mock_cl_cls:
             ChainInterface(chain)
 
-        # Already at MAX_RPCS=10, ChainlistRPC should not be called
+        # Already at MAX_RPCS=20, ChainlistRPC should not be called
         mock_cl_cls.assert_not_called()

{iwa-0.0.61 → iwa-0.0.62}/src/tests/test_safe_executor.py

@@ -567,3 +567,73 @@ def test_rpc_rotation_stops_when_should_not_retry(
         assert success is False
         # Only 1 attempt because should_retry=False
         assert mock_safe_tx.execute.call_count == 1
+
+
+# =============================================================================
+# Test: Fee bumping on base fee errors
+# =============================================================================
+
+
+def test_fee_error_triggers_bump(executor, mock_chain_interface, mock_safe_tx, mock_safe):
+    """Test that fee errors trigger gas price bump on retry."""
+    with patch.object(executor, "_recreate_safe_client", return_value=mock_safe):
+        # First attempt fails with fee error, second succeeds
+        mock_safe_tx.execute.side_effect = [
+            ValueError("max fee per gas less than block base fee: maxFeePerGas: 596, baseFee: 681"),
+            b"tx_hash",
+        ]
+        mock_chain_interface.web3.eth.wait_for_transaction_receipt.return_value = MagicMock(
+            status=1
+        )
+        # Mock fee calculation
+        mock_chain_interface.web3.eth.get_block.return_value = {"baseFeePerGas": 700}
+        mock_chain_interface.web3.eth.max_priority_fee = 1
+
+        with patch("time.sleep"):
+            success, tx_hash, receipt = executor.execute_with_retry(
+                "0xSafe", mock_safe_tx, ["key1"]
+            )
+
+        assert success is True
+        assert mock_safe_tx.execute.call_count == 2
+        # Second call should have tx_gas_price (bumped), not eip1559_speed
+        second_call_kwargs = mock_safe_tx.execute.call_args_list[1][1]
+        assert "tx_gas_price" in second_call_kwargs
+
+
+def test_fee_error_classification(executor):
+    """Test classification of fee-related errors."""
+    fee_errors = [
+        "max fee per gas less than block base fee",
+        "transaction underpriced",
+        "maxFeePerGas too low",
+        "fee too low for mempool",
+    ]
+    for error_msg in fee_errors:
+        error = ValueError(error_msg)
+        result = executor._classify_error(error)
+        assert result["is_fee_error"] is True, f"Should detect fee error: {error_msg}"
+
+
+def test_calculate_bumped_gas_price_eip1559(executor, mock_chain_interface):
+    """Test bumped gas price calculation for EIP-1559 chains."""
+    mock_chain_interface.web3.eth.get_block.return_value = {"baseFeePerGas": 1000}
+    mock_chain_interface.web3.eth.max_priority_fee = 10
+
+    # With 1.3x bump factor: base_fee * 1.3 * 1.5 + priority = 1000 * 1.3 * 1.5 + 10 = 1960
+    result = executor._calculate_bumped_gas_price(1.3)
+
+    assert result is not None
+    assert result == int(1000 * 1.3 * 1.5) + 10
+
+
+def test_calculate_bumped_gas_price_legacy(executor, mock_chain_interface):
+    """Test bumped gas price calculation for legacy chains."""
+    mock_chain_interface.web3.eth.get_block.return_value = {}  # No baseFeePerGas
+    mock_chain_interface.web3.eth.gas_price = 2000
+
+    # Legacy: gas_price * bump_factor = 2000 * 1.3 = 2600
+    result = executor._calculate_bumped_gas_price(1.3)
+
+    assert result is not None
+    assert result == int(2000 * 1.3)