iwa 0.0.16__tar.gz → 0.0.18__tar.gz

{iwa-0.0.16/src/iwa.egg-info → iwa-0.0.18}/PKG-INFO

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

@@ -1,6 +1,6 @@
 [project]
 name = "iwa"
-version = "0.0.16"
+version = "0.0.18"
 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.16"
+target-version = "0.0.18"
 fix = true
 
 [tool.ruff.lint]

{iwa-0.0.16 → iwa-0.0.18}/src/iwa/core/chain/interface.py

@@ -2,9 +2,8 @@
 
 import threading
 import time
-from typing import Callable, Dict, Optional, Tuple, TypeVar, Union
+from typing import Callable, Dict, Optional, TypeVar, Union
 
-from eth_account.datastructures import SignedTransaction
 from web3 import Web3
 
 from iwa.core.chain.errors import TenderlyQuotaExceededError, sanitize_rpc_url
@@ -449,69 +448,6 @@ class ChainInterface:
 
         return False
 
-    def send_native_transfer(
-        self,
-        from_address: EthereumAddress,
-        to_address: EthereumAddress,
-        value_wei: int,
-        sign_callback: Callable[[dict], SignedTransaction],
-    ) -> Tuple[bool, Optional[str]]:
-        """Send native currency transaction with retry logic."""
-
-        def _do_transfer() -> Tuple[bool, Optional[str]]:
-            tx = {
-                "from": from_address,
-                "to": to_address,
-                "value": value_wei,
-                "nonce": self.web3.eth.get_transaction_count(from_address),
-                "chainId": self.chain.chain_id,
-            }
-
-            balance_wei = self.get_native_balance_wei(from_address)
-            gas_price = self.web3.eth.gas_price
-            gas_estimate = self.web3.eth.estimate_gas(tx)
-            required_wei = value_wei + (gas_estimate * gas_price)
-
-            if balance_wei < required_wei:
-                logger.error(
-                    f"Insufficient balance. "
-                    f"Balance: {self.web3.from_wei(balance_wei, 'ether'):.4f} "
-                    f"{self.chain.native_currency}, "
-                    f"Required: {self.web3.from_wei(required_wei, 'ether'):.4f} "
-                    f"{self.chain.native_currency}"
-                )
-                return False, None
-
-            tx["gas"] = gas_estimate
-            tx["gasPrice"] = gas_price
-
-            signed_tx = sign_callback(tx)
-            txn_hash = self.web3.eth.send_raw_transaction(signed_tx.raw_transaction)
-            receipt = self.web3.eth.wait_for_transaction_receipt(txn_hash)
-
-            status = getattr(receipt, "status", None)
-            if status is None and isinstance(receipt, dict):
-                status = receipt.get("status")
-
-            if receipt and status == 1:
-                self.wait_for_no_pending_tx(from_address)
-                logger.info(f"Transaction sent successfully. Tx Hash: {txn_hash.hex()}")
-                # Check Tenderly block limit after each successful transaction
-                self.check_block_limit()
-                return True, receipt["transactionHash"].hex()
-
-            logger.error("Transaction failed (status != 1)")
-            return False, None
-
-        try:
-            return self.with_retry(
-                _do_transfer,
-                operation_name=f"native_transfer to {str(to_address)[:10]}...",
-            )
-        except Exception as e:
-            logger.exception(f"Native transfer failed: {e}")
-            return False, None
-
     def get_token_address(self, token_name: str) -> Optional[EthereumAddress]:
         """Get token address by name"""
         return self.chain.get_token_address(token_name)

{iwa-0.0.16 → iwa-0.0.18}/src/iwa/core/pricing.py

@@ -19,7 +19,6 @@ class PriceService:
     """Service to fetch token prices from CoinGecko."""
 
     BASE_URL = "https://api.coingecko.com/api/v3"
-    DEMO_URL = "https://demo-api.coingecko.com/api/v3"
 
     def __init__(self):
         """Initialize PriceService."""
@@ -60,9 +59,7 @@ class PriceService:
         max_retries = 2
         for attempt in range(max_retries + 1):
             try:
-                # Use demo URL if API key is present, otherwise standard URL
-                # NOTE: Demo URL is significantly more reliable for demo keys
-                base_url = self.DEMO_URL if self.api_key else self.BASE_URL
+                base_url = self.BASE_URL
                 url = f"{base_url}/simple/price"
                 params = {"ids": token_id, "vs_currencies": vs_currency}
                 headers = {}

{iwa-0.0.16 → iwa-0.0.18}/src/iwa/core/services/transaction.py

@@ -1,6 +1,5 @@
 """Transaction service module."""
 
-import time
 from typing import TYPE_CHECKING, Dict, List, Optional, Tuple
 
 from loguru import logger
@@ -31,32 +30,37 @@ class TransferLogger:
         self.account_service = account_service
         self.chain_interface = chain_interface
 
-    def log_transfers(self, receipt: Dict, tx: Dict) -> None:
+    def log_transfers(self, receipt: Dict) -> None:
         """Log all transfers (ERC20 and native) from a transaction receipt.
 
         Args:
             receipt: Transaction receipt containing logs.
-            tx: Original transaction dict.
 
         """
-        # Log native value transfer if present
-        native_value = tx.get("value", 0)
-        if native_value and int(native_value) > 0:
-            self._log_native_transfer(tx, native_value)
+        # Get the original transaction to check for native value transfer
+        tx_hash = receipt.get("transactionHash") or getattr(receipt, "transactionHash", None)
+        if tx_hash:
+            try:
+                tx = self.chain_interface.web3.eth.get_transaction(tx_hash)
+                native_value = getattr(tx, "value", 0) or tx.get("value", 0) if isinstance(tx, dict) else getattr(tx, "value", 0)
+                if native_value and int(native_value) > 0:
+                    from_addr = getattr(tx, "from", "") if hasattr(tx, "from") else tx.get("from", "")
+                    # Handle AttributeDict's special 'from' attribute
+                    if not from_addr and hasattr(tx, "__getitem__"):
+                        from_addr = tx["from"]
+                    to_addr = getattr(tx, "to", "") or (tx.get("to", "") if isinstance(tx, dict) else "")
+                    self._log_native_transfer(from_addr, to_addr, native_value)
+            except Exception as e:
+                logger.debug(f"Could not get tx for native transfer logging: {e}")
 
         # Log ERC20 transfers from event logs
-        logs = receipt.get("logs", [])
-        if hasattr(receipt, "logs"):
-            logs = receipt.logs
+        logs = receipt.get("logs", []) if isinstance(receipt, dict) else getattr(receipt, "logs", [])
 
         for log in logs:
             self._process_log(log)
 
-    def _log_native_transfer(self, tx: Dict, value_wei: int) -> None:
+    def _log_native_transfer(self, from_addr: str, to_addr: str, value_wei: int) -> None:
         """Log a native currency transfer."""
-        from_addr = tx.get("from", "")
-        to_addr = tx.get("to", "")
-
         from_label = self._resolve_address_label(from_addr)
         to_label = self._resolve_address_label(to_addr)
 
@@ -213,53 +217,67 @@ class TransactionService:
         chain_name: str = "gnosis",
         tags: Optional[List[str]] = None,
     ) -> Tuple[bool, Dict]:
-        """Sign and send a transaction with retry logic for gas."""
+        """Sign and send a transaction using unified retry mechanism.
+
+        Uses ChainInterface.with_retry() for consistent RPC rotation and retry logic.
+        Gas errors are handled by increasing gas and retrying within the same mechanism.
+        """
         chain_interface = ChainInterfaces().get(chain_name)
         tx = dict(transaction)
-        max_retries = 10
 
         if not self._prepare_transaction(tx, signer_address_or_tag, chain_interface):
             return False, {}
 
-        for attempt in range(1, max_retries + 1):
+        # Mutable state for retry attempts
+        state = {"gas_retries": 0, "max_gas_retries": 5}
+
+        def _do_sign_send_wait() -> Tuple[bool, Dict, bytes]:
+            """Inner operation wrapped by with_retry."""
             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)
-
-                # 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"
+                txn_hash = chain_interface.web3.eth.send_raw_transaction(
+                    signed_txn.raw_transaction
                 )
+                receipt = chain_interface.web3.eth.wait_for_transaction_receipt(txn_hash)
 
-                if receipt and getattr(receipt, "status", None) == 1:
-                    signer_account = self.account_service.resolve_account(signer_address_or_tag)
-                    chain_interface.wait_for_no_pending_tx(signer_account.address)
-                    logger.info(f"Transaction sent successfully. Tx Hash: {txn_hash.hex()}")
-
-                    self._log_successful_transaction(
-                        receipt, tx, signer_account, chain_name, txn_hash, tags, chain_interface
-                    )
-                    return True, receipt
+                status = getattr(receipt, "status", None)
+                if status is None and isinstance(receipt, dict):
+                    status = receipt.get("status")
 
-                # Transaction reverted
+                if receipt and status == 1:
+                    return True, receipt, txn_hash
+                # Transaction mined but reverted - don't retry
                 logger.error("Transaction failed (status 0).")
-                return False, {}
+                raise ValueError("Transaction reverted")
 
             except web3_exceptions.Web3RPCError as e:
-                if self._handle_gas_error(e, tx, attempt, max_retries):
-                    continue
-                return False, {}
+                # Handle gas errors by increasing gas and re-raising
+                self._handle_gas_retry(e, tx, state)
+                raise  # Re-raise to trigger with_retry's retry mechanism
 
-            except Exception as e:
-                # Attempt RPC rotation
-                if self._handle_generic_error(e, chain_interface, attempt, max_retries):
-                    continue
+        try:
+            success, receipt, txn_hash = chain_interface.with_retry(
+                _do_sign_send_wait,
+                operation_name=f"sign_and_send to {tx.get('to', 'unknown')[:10]}...",
+            )
+            if success:
+                signer_account = self.account_service.resolve_account(signer_address_or_tag)
+                chain_interface.wait_for_no_pending_tx(signer_account.address)
+                logger.info(f"Transaction sent successfully. Tx Hash: {txn_hash.hex()}")
+                self._log_successful_transaction(
+                    receipt, tx, signer_account, chain_name, txn_hash, tags, chain_interface
+                )
+                return True, receipt
+            return False, {}
+        except ValueError as e:
+            # Transaction reverted - already logged
+            if "reverted" in str(e).lower():
                 return False, {}
-
-        return False, {}
+            logger.exception(f"Transaction failed: {e}")
+            return False, {}
+        except Exception as e:
+            logger.exception(f"Transaction failed after retries: {e}")
+            return False, {}
 
     def _prepare_transaction(self, tx: dict, signer_tag: str, chain_interface) -> bool:
         """Ensure nonce and chainId are set."""
@@ -274,32 +292,16 @@ class TransactionService:
             tx["chainId"] = chain_interface.chain.chain_id
         return True
 
-    def _handle_gas_error(self, e, tx, attempt, max_retries) -> bool:
-        err_text = str(e)
-        if self._is_gas_too_low_error(err_text) and attempt < max_retries:
-            logger.warning(
-                f"Gas too low error detected. Retrying with increased gas (Attempt {attempt}/{max_retries})..."
-            )
+    def _handle_gas_retry(self, e: Exception, tx: dict, state: dict) -> None:
+        """Increase gas if error is gas-related and retries remaining."""
+        if self._is_gas_too_low_error(str(e)) and state["gas_retries"] < state["max_gas_retries"]:
             current_gas = int(tx.get("gas", 30_000))
             tx["gas"] = int(current_gas * 1.5)
-            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
-
-    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...")
-                # Exponential backoff
-                time.sleep(min(2**attempt, 30))
-                return True
-        logger.exception(f"Unexpected error sending transaction: {e}")
-        return False
+            state["gas_retries"] += 1
+            logger.warning(
+                f"Gas too low, increasing to {tx['gas']} "
+                f"(attempt {state['gas_retries']}/{state['max_gas_retries']})"
+            )
 
     def _log_successful_transaction(
         self, receipt, tx, signer_account, chain_name, txn_hash, tags, chain_interface
@@ -323,7 +325,7 @@ class TransactionService:
 
             # Log transfer events (ERC20 and native value)
             transfer_logger = TransferLogger(self.account_service, chain_interface)
-            transfer_logger.log_transfers(receipt, tx)
+            transfer_logger.log_transfers(receipt)
 
         except Exception as log_err:
             logger.warning(f"Failed to log transaction: {log_err}")

{iwa-0.0.16 → iwa-0.0.18}/src/iwa/core/services/transfer/erc20.py

@@ -64,6 +64,14 @@ class ERC20TransferMixin:
             value_eur=v_eur,
             tags=["erc20-transfer", "safe-transaction"],
         )
+
+        # Log transfers extracted from receipt events
+        if receipt:
+            from iwa.core.services.transaction import TransferLogger
+
+            transfer_logger = TransferLogger(self.account_service, interface)
+            transfer_logger.log_transfers(receipt)
+
         return tx_hash
 
     def _send_erc20_via_eoa(

{iwa-0.0.16 → iwa-0.0.18}/src/iwa/core/services/transfer/native.py

@@ -61,6 +61,15 @@ class NativeTransferMixin:
             value_eur=v_eur,
             tags=["native-transfer", "safe-transaction"],
         )
+
+        # Log transfers extracted from receipt events
+        if receipt:
+            from iwa.core.services.transaction import TransferLogger
+
+            interface = ChainInterfaces().get(chain_name)
+            transfer_logger = TransferLogger(self.account_service, interface)
+            transfer_logger.log_transfers(receipt)
+
         return tx_hash
 
     def _send_native_via_eoa(
@@ -74,20 +83,38 @@ class NativeTransferMixin:
         to_tag: Optional[str],
         token_symbol: str,
     ) -> Optional[str]:
-        """Send native currency via EOA (externally owned account)."""
-        success, tx_hash = chain_interface.send_native_transfer(
-            from_address=from_account.address,
-            to_address=to_address,
-            value_wei=amount_wei,
-            sign_callback=lambda tx: self.key_storage.sign_transaction(tx, from_account.address),
+        """Send native currency via EOA using unified TransactionService."""
+        # Build transaction dict
+        try:
+            gas_price = chain_interface.web3.eth.gas_price
+            gas_estimate = chain_interface.web3.eth.estimate_gas({
+                "from": from_account.address,
+                "to": to_address,
+                "value": amount_wei,
+            })
+        except Exception as e:
+            logger.error(f"Failed to estimate gas for native transfer: {e}")
+            return None
+
+        tx = {
+            "from": from_account.address,
+            "to": to_address,
+            "value": amount_wei,
+            "gas": gas_estimate,
+            "gasPrice": gas_price,
+        }
+
+        # Use unified TransactionService
+        success, receipt = self.transaction_service.sign_and_send(
+            tx, from_account.address, chain_name, tags=["native-transfer"]
         )
-        if success and tx_hash:
-            # Get receipt for gas calculation
-            receipt = None
-            try:
-                receipt = chain_interface.web3.eth.get_transaction_receipt(tx_hash)
-            except Exception as e:
-                logger.warning(f"Could not get receipt for {tx_hash}: {e}")
+
+        if success and receipt:
+            tx_hash = receipt.get("transactionHash", b"")
+            if hasattr(tx_hash, "hex"):
+                tx_hash = tx_hash.hex()
+            elif isinstance(tx_hash, bytes):
+                tx_hash = tx_hash.hex()
 
             gas_cost, gas_value_eur = self._calculate_gas_info(receipt, chain_name)
             p_eur, v_eur = self._get_token_price_info(token_symbol, amount_wei, chain_name)
@@ -106,6 +133,13 @@ class NativeTransferMixin:
                 value_eur=v_eur,
                 tags=["native-transfer"],
             )
+
+            # Log transfers extracted from receipt events
+            from iwa.core.services.transaction import TransferLogger
+
+            transfer_logger = TransferLogger(self.account_service, chain_interface)
+            transfer_logger.log_transfers(receipt)
+
             return tx_hash
         return None
 

{iwa-0.0.16 → iwa-0.0.18}/src/iwa/plugins/olas/service_manager/mech.py

@@ -140,11 +140,13 @@ class MechManagerMixin:
             )
             if use_marketplace:
                 priority_mech = priority_mech or detected_priority_mech
+                mech_address = mech_address or detected_marketplace
 
         if use_marketplace:
             return self._send_marketplace_mech_request(
                 data=data,
                 value=value,
+                marketplace_address=mech_address,
                 priority_mech=priority_mech,
                 max_delivery_rate=max_delivery_rate,
                 payment_type=payment_type,
@@ -260,10 +262,39 @@ class MechManagerMixin:
 
         return True
 
+    def _resolve_marketplace_config(
+        self, marketplace_addr: Optional[str], priority_addr: Optional[str]
+    ) -> tuple[str, str]:
+        """Resolve marketplace and priority mech addresses. Returns (marketplace, priority)."""
+        chain_name = self.chain_name if self.service else getattr(self, "chain_name", "gnosis")
+        protocol_contracts = OLAS_CONTRACTS.get(chain_name, {})
+
+        resolved_mp = marketplace_addr or protocol_contracts.get("OLAS_MECH_MARKETPLACE")
+        if not resolved_mp:
+            raise ValueError(f"Mech Marketplace address not found for chain {chain_name}")
+
+        if not priority_addr:
+            raise ValueError("priority_mech is required for marketplace requests")
+
+        return str(resolved_mp), Web3.to_checksum_address(priority_addr)
+
+    def _prepare_marketplace_params(
+        self,
+        value: Optional[int],
+        max_delivery_rate: Optional[int],
+        payment_type: Optional[bytes],
+    ) -> tuple[int, int, bytes]:
+        """Prepare default values for marketplace parameters."""
+        p_type = payment_type or bytes.fromhex(PAYMENT_TYPE_NATIVE)
+        val = value if value is not None else 10_000_000_000_000_000
+        rate = max_delivery_rate if max_delivery_rate is not None else val
+        return val, rate, p_type
+
     def _send_marketplace_mech_request(
         self,
         data: bytes,
         value: Optional[int] = None,
+        marketplace_address: Optional[str] = None,
         priority_mech: Optional[str] = None,
         max_delivery_rate: Optional[int] = None,
         payment_type: Optional[bytes] = None,
@@ -275,43 +306,30 @@ class MechManagerMixin:
             logger.error("No active service")
             return None
 
-        multisig_address = self.service.multisig_address
-        chain_name = self.chain_name if self.service else getattr(self, "chain_name", "gnosis")
-        protocol_contracts = OLAS_CONTRACTS.get(chain_name, {})
-        marketplace_address = protocol_contracts.get("OLAS_MECH_MARKETPLACE")
-
-        if not marketplace_address:
-            logger.error(f"Mech Marketplace address not found for chain {chain_name}")
-            return None
-
-        if not priority_mech:
-            logger.error("priority_mech is required for marketplace requests")
+        try:
+            marketplace_address, priority_mech = self._resolve_marketplace_config(
+                marketplace_address, priority_mech
+            )
+        except ValueError as e:
+            logger.error(e)
             return None
 
-        priority_mech = Web3.to_checksum_address(priority_mech)
-        marketplace = MechMarketplaceContract(str(marketplace_address), chain_name=chain_name)
+        marketplace = MechMarketplaceContract(marketplace_address, chain_name=self.chain_name)
 
         if not self._validate_priority_mech(marketplace, priority_mech):
             return None
 
-        # Set defaults for payment
-        if payment_type is None:
-            payment_type = bytes.fromhex(PAYMENT_TYPE_NATIVE)
-
-        if value is None:
-            value = 10_000_000_000_000_000
-            logger.info(f"Using default value: {value} wei (0.01 xDAI)")
-
-        if max_delivery_rate is None:
-            max_delivery_rate = value
-            logger.info(f"Using value as max_delivery_rate: {max_delivery_rate}")
+        # Set defaults for payment and delivery
+        value, max_delivery_rate, payment_type = self._prepare_marketplace_params(
+            value, max_delivery_rate, payment_type
+        )
 
         if not self._validate_marketplace_params(marketplace, response_timeout, payment_type):
             return None
 
         # Prepare transaction
         tx_data = marketplace.prepare_request_tx(
-            from_address=multisig_address,
+            from_address=self.service.multisig_address,
             request_data=data,
             priority_mech=priority_mech,
             response_timeout=response_timeout,

{iwa-0.0.16 → iwa-0.0.18/src/iwa.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: iwa
-Version: 0.0.16
+Version: 0.0.18
 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.16 → iwa-0.0.18}/src/tests/test_chain.py

@@ -195,43 +195,8 @@ def test_wait_for_no_pending_tx(mock_web3):
             assert ci.wait_for_no_pending_tx("0xSender") is False
 
 
-def test_send_native_transfer(mock_web3):
-    chain = MagicMock(spec=SupportedChain, rpcs=["https://rpc"], chain_id=1, native_currency="ETH")
-    chain.name = "TestChain"
-    type(chain).rpc = PropertyMock(return_value="https://rpc")
-    ci = ChainInterface(chain)
-    account = MagicMock(address="0xSender", key="key")
-
-    ci.web3.eth.get_transaction_count.return_value = 0
-    ci.web3.eth.gas_price = 10
-    ci.web3.eth.estimate_gas.return_value = 21000
-
-    # Sufficient balance
-    ci.web3.eth.get_balance.return_value = 10**18  # plenty
-    ci.web3.eth.get_balance.return_value = 10**18  # plenty
-    # Valid mock return for success: (True, dict_receipt)
-    # The actual method returns tx_hash.hex().
-    mock_signed_tx = MagicMock()
-    mock_signed_tx.raw_transaction = b"raw"
-    mock_receipt = {"transactionHash": b"hash", "status": 1}
-
-    with (
-        patch.object(ci.web3.eth, "send_raw_transaction", return_value=b"hash"),
-        patch.object(ci.web3.eth, "wait_for_transaction_receipt", return_value=mock_receipt),
-        patch.object(ci, "wait_for_no_pending_tx", return_value=True),
-    ):
-        success, tx_hash = ci.send_native_transfer(
-            account.address, "0xReceiver", 1000, sign_callback=lambda tx: mock_signed_tx
-        )
-        assert success is True
-        assert tx_hash == "68617368"
-
-    # Insufficient balance
-    ci.web3.eth.get_balance.return_value = 0
-    ci.web3.from_wei.return_value = 0.0
-    assert ci.send_native_transfer(
-        account.address, "0xReceiver", 1000, sign_callback=lambda tx: mock_signed_tx
-    ) == (False, None)
+# NOTE: test_send_native_transfer was removed because the method was removed
+# from ChainInterface. Native transfers now go through TransactionService.
 
 
 def test_chain_interfaces_get():
@@ -352,66 +317,6 @@ def test_chain_interface_with_real_chains():
 # --- Negative Tests ---
 
 
-def test_send_native_transfer_insufficient_balance(mock_web3):
-    """Test send_native_transfer fails with insufficient balance."""
-    chain = MagicMock(spec=SupportedChain)
-    chain.name = "TestChain"
-    chain.rpcs = ["https://rpc"]
-    chain.chain_id = 1
-    chain.native_currency = "ETH"
-    type(chain).rpc = PropertyMock(return_value="https://rpc")
-
-    ci = ChainInterface(chain)
-    ci.web3.eth.get_transaction_count.return_value = 0
-    ci.web3.eth.gas_price = 1000000000  # 1 gwei
-    ci.web3.eth.estimate_gas.return_value = 21000
-    ci.web3.eth.get_balance.return_value = 1000  # Very low balance
-    ci.web3.from_wei.return_value = 0.000001
-
-    sign_callback = MagicMock()
-
-    success, tx_hash = ci.send_native_transfer(
-        from_address="0x1111111111111111111111111111111111111111",
-        to_address="0x2222222222222222222222222222222222222222",
-        value_wei=10**18,  # 1 ETH - more than available
-        sign_callback=sign_callback,
-    )
-
-    assert success is False
-    assert tx_hash is None
-    sign_callback.assert_not_called()
-
-
-def test_send_native_transfer_rpc_error(mock_web3):
-    """Test send_native_transfer handles RPC errors."""
-    chain = MagicMock(spec=SupportedChain)
-    chain.name = "TestChain"
-    chain.rpcs = ["https://rpc"]
-    chain.chain_id = 1
-    chain.native_currency = "ETH"
-    type(chain).rpc = PropertyMock(return_value="https://rpc")
-
-    ci = ChainInterface(chain)
-    ci.web3.eth.get_transaction_count.return_value = 0
-    ci.web3.eth.gas_price = 1000000000
-    ci.web3.eth.estimate_gas.return_value = 21000
-    ci.web3.eth.get_balance.return_value = 10**19  # Enough balance
-    ci.web3.from_wei.return_value = 10.0
-    ci.web3.eth.send_raw_transaction.side_effect = Exception("Connection refused")
-
-    sign_callback = MagicMock()
-    sign_callback.return_value = MagicMock(raw_transaction=b"signed")
-
-    success, tx_hash = ci.send_native_transfer(
-        from_address="0x1111111111111111111111111111111111111111",
-        to_address="0x2222222222222222222222222222222222222222",
-        value_wei=10**17,
-        sign_callback=sign_callback,
-    )
-
-    assert success is False
-    assert tx_hash is None
-
 
 def test_get_token_symbol_fallback_on_error(mock_web3):
     """Test get_token_symbol returns truncated address on error."""