iwa 0.0.61__py3-none-any.whl → 0.0.64__py3-none-any.whl

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/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/plugins/olas/models.py

@@ -2,7 +2,7 @@
 
 from typing import Dict, List, Optional
 
-from pydantic import BaseModel, Field, root_validator
+from pydantic import BaseModel, Field
 
 from iwa.core.models import EthereumAddress
 
@@ -15,37 +15,20 @@ class Service(BaseModel):
     service_id: int  # Unique per chain
     agent_ids: List[int] = Field(default_factory=list)  # List of agent type IDs
 
-    # New explicit owner fields
+    # Owner fields:
+    # - service_owner_eoa_address: EOA that owns the service (or signs for the multisig)
+    # - service_owner_multisig_address: Safe multisig owner (optional, if service is owned by a Safe)
     service_owner_eoa_address: Optional[EthereumAddress] = None
     service_owner_multisig_address: Optional[EthereumAddress] = None
 
-    # Deprecated fields (kept for migration, removed from physical model via aliasing/validation)
-    # Actually, we keep it optional but not used, or use migration logic.
-    # Let's remove it from fields and rely on before validator to map it to eoa.
-
     agent_address: Optional[EthereumAddress] = None
     multisig_address: Optional[EthereumAddress] = None
     staking_contract_address: Optional[EthereumAddress] = None
     token_address: Optional[EthereumAddress] = None
 
-    @root_validator(pre=True)
-    def migrate_owner_fields(cls, values):  # noqa: N805
-        """Migrate legacy service_owner_address to service_owner_eoa_address."""
-        # Check for legacy 'service_owner_address'
-        if "service_owner_address" in values and values["service_owner_address"]:
-            legacy_addr = values["service_owner_address"]
-
-            # If service_owner_eoa_address is missing, use legacy
-            if "service_owner_eoa_address" not in values or not values["service_owner_eoa_address"]:
-                values["service_owner_eoa_address"] = legacy_addr
-
-            # Remove legacy field from values so it doesn't cause extra field errors if we removed it from model
-            # Or if strict.
-        return values
-
     @property
     def service_owner_address(self) -> Optional[EthereumAddress]:
-        """Backward compatibility property: Returns effective owner (Safe if present, else EOA)."""
+        """Returns effective owner address (Safe multisig if present, else EOA)."""
         return self.service_owner_multisig_address or self.service_owner_eoa_address
 
     @property

iwa/plugins/olas/service_manager/drain.py

@@ -12,7 +12,9 @@ from iwa.plugins.olas.contracts.staking import StakingContract, StakingState
 class DrainManagerMixin:
     """Mixin for draining and service token management."""
 
-    def claim_rewards(self, staking_contract: Optional[StakingContract] = None) -> Tuple[bool, int]:
+    def claim_rewards(  # noqa: C901
+        self, staking_contract: Optional[StakingContract] = None
+    ) -> Tuple[bool, int]:
         """Claim staking rewards for the active service.
 
         The claimed OLAS tokens will be sent to the service's multisig (Safe).
@@ -51,13 +53,19 @@ class DrainManagerMixin:
             logger.info("Service not staked, skipping claim")
             return False, 0
 
-        # Check accrued rewards
-        accrued_rewards = staking_contract.get_accrued_rewards(service_id)
-        if accrued_rewards == 0:
-            logger.info("No accrued rewards to claim")
+        # Check claimable rewards using calculate_staking_reward for accurate value
+        # (get_accrued_rewards returns stored value which may be outdated)
+        try:
+            claimable_rewards = staking_contract.calculate_staking_reward(service_id)
+        except Exception:
+            # Fallback to stored value if calculation fails
+            claimable_rewards = staking_contract.get_accrued_rewards(service_id)
+
+        if claimable_rewards == 0:
+            logger.info("No rewards to claim")
             return False, 0
 
-        logger.info(f"Claiming {accrued_rewards / 1e18:.4f} OLAS rewards for service {service_id}")
+        logger.info(f"Claiming ~{claimable_rewards / 1e18:.4f} OLAS rewards for service {service_id}")
 
         # Use service owner which holds the reward rights (not necessarily master)
         owner_address = self.service.service_owner_address or self.wallet.master_account.address
@@ -83,11 +91,19 @@ class DrainManagerMixin:
             return False, 0
 
         events = staking_contract.extract_events(receipt)
-        if "RewardClaimed" not in [event["name"] for event in events]:
-            logger.warning("RewardClaimed event not found, but transaction succeeded")
 
-        logger.info(f"Successfully claimed {accrued_rewards / 1e18:.4f} OLAS rewards")
-        return True, accrued_rewards
+        # Extract actual claimed amount from RewardClaimed event
+        claimed_amount = claimable_rewards  # Default to estimated
+        for event in events:
+            if event["name"] == "RewardClaimed":
+                # RewardClaimed event has 'amount' or 'reward' field
+                claimed_amount = event["args"].get("amount", event["args"].get("reward", claimed_amount))
+                break
+        else:
+            logger.warning("RewardClaimed event not found, using estimated amount")
+
+        logger.info(f"Successfully claimed {claimed_amount / 1e18:.4f} OLAS rewards")
+        return True, claimed_amount
 
     def withdraw_rewards(self) -> Tuple[bool, float]:
         """Withdraw OLAS from the service Safe to the configured withdrawal address.
@@ -132,8 +148,14 @@ class DrainManagerMixin:
             return False, 0
 
         olas_amount = olas_balance / 1e18
-        withdrawal_tag = self.wallet.get_tag_by_address(withdrawal_address) or withdrawal_address
-        multisig_tag = self.wallet.get_tag_by_address(multisig_address) or multisig_address
+        withdrawal_tag = (
+            self.wallet.account_service.get_tag_by_address(withdrawal_address)
+            or withdrawal_address
+        )
+        multisig_tag = (
+            self.wallet.account_service.get_tag_by_address(multisig_address)
+            or multisig_address
+        )
 
         logger.info(f"Withdrawing {olas_amount:.4f} OLAS from {multisig_tag} to {withdrawal_tag}")
 

iwa/plugins/olas/service_manager/lifecycle.py

@@ -183,7 +183,7 @@ class LifecycleManagerMixin:
             service_name=service_name,
             chain_name=chain_name,
             agent_id_values=agent_id_values,
-            service_owner_address=service_owner_account.address,
+            service_owner_eoa_address=service_owner_account.address,
             token_address=token_address,
         )
 
@@ -263,7 +263,7 @@ class LifecycleManagerMixin:
         service_name: Optional[str],
         chain_name: str,
         agent_id_values: List[int],
-        service_owner_address: str,
+        service_owner_eoa_address: str,
         token_address: Optional[str],
     ) -> None:
         """Create and save the new Service model."""
@@ -272,7 +272,7 @@ class LifecycleManagerMixin:
             chain_name=chain_name,
             service_id=service_id,
             agent_ids=agent_id_values,
-            service_owner_address=service_owner_address,
+            service_owner_eoa_address=service_owner_eoa_address,
             token_address=token_address,
         )
 

iwa/plugins/olas/tests/test_olas_models.py

@@ -14,7 +14,7 @@ class TestOlasConfig:
             chain_name="gnosis",
             service_id=456,
             agent_ids=[25],
-            service_owner_address="0x1234567890123456789012345678901234567890",
+            service_owner_eoa_address="0x1234567890123456789012345678901234567890",
         )
 
         config.add_service(service)
@@ -30,7 +30,7 @@ class TestOlasConfig:
             chain_name="gnosis",
             service_id=789,
             agent_ids=[25],
-            service_owner_address="0x1234567890123456789012345678901234567890",
+            service_owner_eoa_address="0x1234567890123456789012345678901234567890",
         )
         config.services["gnosis:789"] = service
 
@@ -53,7 +53,7 @@ class TestOlasConfig:
             chain_name="ethereum",
             service_id=200,
             agent_ids=[25],
-            service_owner_address="0x1234567890123456789012345678901234567890",
+            service_owner_eoa_address="0x1234567890123456789012345678901234567890",
         )
         config.services["ethereum:200"] = service
 
@@ -116,7 +116,7 @@ class TestService:
             chain_name="gnosis",
             service_id=123,
             agent_ids=[25],
-            service_owner_address="0x1234567890123456789012345678901234567890",
+            service_owner_eoa_address="0x1234567890123456789012345678901234567890",
         )
 
         assert service.key == "gnosis:123"
@@ -133,7 +133,7 @@ class TestService:
             chain_name="gnosis",
             service_id=456,
             agent_ids=[25],
-            service_owner_address="0x1234567890123456789012345678901234567890",
+            service_owner_eoa_address="0x1234567890123456789012345678901234567890",
             staking_contract_address=staking_addr,
             token_address=token_addr,
         )

iwa/plugins/olas/tests/test_olas_view_actions.py

@@ -35,7 +35,7 @@ def mock_olas_config():
         chain_name="gnosis",
         agent_address=VALID_ADDR_1,
         multisig_address=VALID_ADDR_2,
-        service_owner_address=VALID_ADDR_3,
+        service_owner_eoa_address=VALID_ADDR_3,
         staking_contract_address=VALID_ADDR_1,
     )
     config = OlasConfig(services={"gnosis:1": service})

iwa/plugins/olas/tests/test_service_manager_rewards.py

@@ -108,6 +108,7 @@ def test_claim_rewards_no_accrued_rewards(mock_wallet):
 
     mock_staking = MagicMock()
     mock_staking.get_staking_state.return_value = StakingState.STAKED
+    mock_staking.calculate_staking_reward.return_value = 0
     mock_staking.get_accrued_rewards.return_value = 0
 
     success, amount = manager.claim_rewards(staking_contract=mock_staking)
@@ -129,9 +130,12 @@ def test_claim_rewards_success(mock_wallet):
 
     mock_staking = MagicMock()
     mock_staking.get_staking_state.return_value = StakingState.STAKED
+    mock_staking.calculate_staking_reward.return_value = 10 * 10**18  # 10 OLAS
     mock_staking.get_accrued_rewards.return_value = 10 * 10**18  # 10 OLAS
     mock_staking.prepare_claim_tx.return_value = {"data": "0x"}
-    mock_staking.extract_events.return_value = [{"name": "RewardClaimed"}]
+    mock_staking.extract_events.return_value = [
+        {"name": "RewardClaimed", "args": {"amount": 10 * 10**18}}
+    ]
 
     success, amount = manager.claim_rewards(staking_contract=mock_staking)
 
@@ -152,6 +156,7 @@ def test_claim_rewards_tx_fails(mock_wallet):
 
     mock_staking = MagicMock()
     mock_staking.get_staking_state.return_value = StakingState.STAKED
+    mock_staking.calculate_staking_reward.return_value = 10 * 10**18
     mock_staking.get_accrued_rewards.return_value = 10 * 10**18
     mock_staking.prepare_claim_tx.return_value = {"data": "0x"}
     mock_wallet.sign_and_send_transaction.return_value = (False, {})

iwa/plugins/olas/tests/test_service_staking.py

@@ -201,6 +201,7 @@ def test_sm_claim_rewards_tx_fails(mock_wallet):
         mock_staking = MagicMock()
         mock_staking.prepare_claim_tx.return_value = {"to": VALID_ADDR}
         mock_staking.get_staking_state.return_value = StakingState.STAKED
+        mock_staking.calculate_staking_reward.return_value = 100
         mock_staking.get_accrued_rewards.return_value = 100
 
         def get_contract_side_effect(cls, *args, **kwargs):

iwa/web/tests/test_web_olas.py

@@ -43,7 +43,7 @@ def mock_olas_config():
         chain_name="gnosis",
         agent_address="0x78731D3Ca6b7E34aC0F824c42a7cC18A495cabaB",
         multisig_address="0x40A2aCCbd92BCA938b02010E17A5b8929b49130D",
-        service_owner_address="0x1111111111111111111111111111111111111111",
+        service_owner_eoa_address="0x1111111111111111111111111111111111111111",
         staking_contract_address="0x78731D3Ca6b7E34aC0F824c42a7cC18A495cabaB",
     )
     return OlasConfig(services={"gnosis:1": service})

{iwa-0.0.61.dist-info → iwa-0.0.64.dist-info}/METADATA

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