iwa 0.0.33__py3-none-any.whl → 0.0.59__py3-none-any.whl

iwa/core/services/safe_executor.py

@@ -0,0 +1,350 @@
+"""Safe transaction executor with retry logic and gas handling."""
+
+import time
+from typing import TYPE_CHECKING, Dict, List, Optional, Tuple
+
+from loguru import logger
+from safe_eth.eth import EthereumClient, TxSpeed
+from safe_eth.safe import Safe
+from safe_eth.safe.safe_tx import SafeTx
+
+from iwa.core.contracts.decoder import ErrorDecoder
+from iwa.core.models import Config
+
+if TYPE_CHECKING:
+    from iwa.core.chain import ChainInterface
+
+
+# Simple in-memory counters for debugging
+SAFE_TX_STATS = {
+    "total_attempts": 0,
+    "gas_retries": 0,
+    "nonce_retries": 0,
+    "rpc_rotations": 0,
+    "final_successes": 0,
+    "final_failures": 0,
+    "signature_errors": 0,
+}
+
+# Minimum signature length (65 bytes per signature for ECDSA)
+MIN_SIGNATURE_LENGTH = 65
+
+
+class SafeTransactionExecutor:
+    """Execute Safe transactions with retry, gas estimation, and RPC rotation."""
+
+    DEFAULT_MAX_RETRIES = 6
+    DEFAULT_RETRY_DELAY = 1.0
+    GAS_BUFFER_PERCENTAGE = 1.5  # 50% buffer
+    MAX_GAS_MULTIPLIER = 10  # Hard cap: never exceed 10x original estimate
+    DEFAULT_FALLBACK_GAS = 500_000  # Fallback when estimation fails
+
+    def __init__(
+        self,
+        chain_interface: "ChainInterface",
+        max_retries: Optional[int] = None,
+        gas_buffer: Optional[float] = None,
+    ):
+        """Initialize the executor."""
+        self.chain_interface = chain_interface
+
+        # Use centralized config with fallbacks
+        config = Config().core
+        self.max_retries = max_retries or config.safe_tx_max_retries
+        self.gas_buffer = gas_buffer or config.safe_tx_gas_buffer
+        self._client_cache: Dict[str, EthereumClient] = {}
+
+    def execute_with_retry(
+        self,
+        safe_address: str,
+        safe_tx: SafeTx,
+        signer_keys: List[str],
+        operation_name: str = "safe_tx",
+    ) -> Tuple[bool, str, Optional[Dict]]:
+        """Execute SafeTx with full retry mechanism.
+
+        Args:
+            safe_address: The address of the Safe.
+            safe_tx: The Safe transaction object.
+            signer_keys: List of private keys for signing.
+            operation_name: Name for logging purposes.
+
+        Returns:
+            Tuple of (success, tx_hash_or_error, receipt)
+
+        """
+        last_error = None
+        current_gas = safe_tx.safe_tx_gas
+        base_estimate = current_gas if current_gas > 0 else 0
+
+        for attempt in range(self.max_retries + 1):
+            SAFE_TX_STATS["total_attempts"] += 1
+            try:
+                # Prepare and execute attempt
+                tx_hash = self._execute_attempt(
+                    safe_address,
+                    safe_tx,
+                    signer_keys,
+                    operation_name,
+                    attempt,
+                    current_gas,
+                    base_estimate,
+                )
+
+                # Check receipt
+                receipt = self.chain_interface.web3.eth.wait_for_transaction_receipt(tx_hash)
+                if self._check_receipt_status(receipt):
+                    SAFE_TX_STATS["final_successes"] += 1
+                    logger.info(
+                        f"[{operation_name}] Success on attempt {attempt + 1}. Tx Hash: {tx_hash}"
+                    )
+                    return True, tx_hash, receipt
+
+                logger.error(
+                    f"[{operation_name}] Mined but failed (status 0) on attempt {attempt + 1}."
+                )
+                raise ValueError("Transaction reverted on-chain")
+
+            except Exception as e:
+                updated_tx, should_retry = self._handle_execution_failure(
+                    e, safe_address, safe_tx, attempt, operation_name
+                )
+                last_error = e
+                if not should_retry:
+                    break
+
+                # 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
+
+                delay = self.DEFAULT_RETRY_DELAY * (2**attempt)
+                time.sleep(delay)
+
+        return False, str(last_error), None
+
+    def _execute_attempt(
+        self,
+        safe_address,
+        safe_tx,
+        signer_keys,
+        operation_name,
+        attempt,
+        current_gas,
+        base_estimate,
+    ) -> str:
+        """Prepare client, estimate gas, simulate, and execute."""
+        # 1. (Re)Create Safe client
+        self._recreate_safe_client(safe_address)
+
+        # NOTE: We do NOT modify safe_tx_gas here because the transaction is already signed.
+        # The Safe tx hash includes safe_tx_gas, so changing it would invalidate all signatures.
+        # Gas estimation must happen BEFORE signing in SafeService.
+
+        # 2. Validate signatures exist before any operation
+        sig_len = len(safe_tx.signatures) if safe_tx.signatures else 0
+        if sig_len < MIN_SIGNATURE_LENGTH:
+            SAFE_TX_STATS["signature_errors"] += 1
+            raise ValueError(
+                f"No valid signatures on transaction (have {sig_len} bytes, need >= {MIN_SIGNATURE_LENGTH})"
+            )
+
+        # 3. Simulate locally
+        try:
+            safe_tx.call()
+        except Exception as e:
+            classification = self._classify_error(e)
+            # Signature errors (GS020, GS026) are not recoverable - fail immediately
+            if classification["is_signature_error"]:
+                SAFE_TX_STATS["signature_errors"] += 1
+                reason = self._decode_revert_reason(e)
+                logger.error(f"[{operation_name}] Signature error (not retryable): {reason or e}")
+                raise e
+            if classification["is_revert"] and not classification["is_nonce_error"]:
+                reason = self._decode_revert_reason(e)
+                logger.error(f"[{operation_name}] Simulation reverted: {reason or e}")
+                raise e
+            raise
+
+        # 4. Execute
+        # IMPORTANT: safe-eth-py's execute() method CLEARS signatures after execution.
+        # We must backup and restore them to support retries if something goes wrong (e.g. timeout after broadcast).
+        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)
+
+        finally:
+            # Restore signatures for next attempt if needed
+            # (execute() clears them on lines 407-409 of safe_eth/safe/safe_tx.py)
+            if safe_tx.signatures != signatures_backup:
+                safe_tx.signatures = signatures_backup
+
+    def _check_receipt_status(self, receipt) -> bool:
+        """Check if receipt has successful status."""
+        status = getattr(receipt, "status", None)
+        if status is None and isinstance(receipt, dict):
+            status = receipt.get("status")
+        return status == 1
+
+    def _handle_execution_failure(
+        self,
+        error: Exception,
+        safe_address: str,
+        safe_tx: SafeTx,
+        attempt: int,
+        operation_name: str,
+    ) -> Tuple[SafeTx, bool]:
+        """Handle execution failure and determine next steps."""
+        classification = self._classify_error(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
+
+        strategy = "retry"
+        safe = self._recreate_safe_client(safe_address)
+
+        if classification["is_nonce_error"]:
+            strategy = "nonce refresh"
+            SAFE_TX_STATS["nonce_retries"] += 1
+            safe_tx = self._refresh_nonce(safe, safe_tx)
+        elif classification["is_rpc_error"]:
+            strategy = "RPC rotation"
+            SAFE_TX_STATS["rpc_rotations"] += 1
+            result = self.chain_interface._handle_rpc_error(error)
+            if not result["should_retry"]:
+                return safe_tx, False
+        elif classification["is_gas_error"]:
+            strategy = "gas increase"
+            # Gas increase handled in next attempt loop
+
+        self._log_retry(attempt + 1, error, strategy)
+        return safe_tx, True
+
+    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."""
+        try:
+            # Use on-chain simulation via safe-eth-py
+            estimated = safe.estimate_tx_gas(
+                safe_tx.to, safe_tx.value, safe_tx.data, safe_tx.operation
+            )
+            with_buffer = int(estimated * self.gas_buffer)
+
+            # Apply x10 hard cap if we have a base estimate
+            if base_estimate > 0:
+                max_allowed = base_estimate * self.MAX_GAS_MULTIPLIER
+                if with_buffer > max_allowed:
+                    logger.warning(f"Gas {with_buffer} exceeds x10 cap, capping to {max_allowed}")
+                    return max_allowed
+
+            return with_buffer
+        except Exception as e:
+            logger.warning(f"Gas estimation failed, using fallback: {e}")
+            return self.DEFAULT_FALLBACK_GAS
+
+    def _recreate_safe_client(self, safe_address: str) -> Safe:
+        """Recreate Safe with current (possibly rotated) RPC."""
+        rpc_url = self.chain_interface.current_rpc
+        if rpc_url not in self._client_cache:
+            self._client_cache[rpc_url] = EthereumClient(rpc_url)
+        ethereum_client = self._client_cache[rpc_url]
+        return Safe(safe_address, ethereum_client)
+
+    def _is_nonce_error(self, error: Exception) -> bool:
+        """Check if error is due to Safe nonce conflict."""
+        error_text = str(error).lower()
+        # GS025 = Invalid nonce (NOT GS026 which is invalid signatures)
+        return any(x in error_text for x in ["nonce", "gs025", "already executed", "duplicate"])
+
+    def _is_signature_error(self, error: Exception) -> bool:
+        """Check if error is due to invalid Safe signatures.
+
+        GS020 = Signatures data too short
+        GS021 = Invalid signature data pointer
+        GS024 = Invalid contract signature
+        GS026 = Invalid owner (signature from non-owner)
+        """
+        error_text = str(error).lower()
+        return any(
+            x in error_text
+            for x in [
+                "gs020",
+                "gs021",
+                "gs024",
+                "gs026",
+                "invalid signatures",
+                "signatures data too short",
+            ]
+        )
+
+    def _refresh_nonce(self, safe: Safe, safe_tx: SafeTx) -> SafeTx:
+        """Re-fetch nonce and rebuild transaction."""
+        current_nonce = safe.retrieve_nonce()
+        logger.info(f"Refreshing Safe nonce to {current_nonce}")
+        return safe.build_multisig_tx(
+            safe_tx.to,
+            safe_tx.value,
+            safe_tx.data,
+            safe_tx.operation,
+            safe_tx_gas=safe_tx.safe_tx_gas,
+            base_gas=safe_tx.base_gas,
+            gas_price=safe_tx.gas_price,
+            gas_token=safe_tx.gas_token,
+            refund_receiver=safe_tx.refund_receiver,
+            # Note: signatures are NOT copied - tx hash changes with new nonce
+            safe_nonce=current_nonce,
+        )
+
+    def _classify_error(self, error: Exception) -> dict:
+        """Classify Safe transaction errors for retry decisions."""
+        err_text = str(error).lower()
+        is_rpc = self.chain_interface._is_rate_limit_error(
+            error
+        ) or self.chain_interface._is_connection_error(error)
+
+        return {
+            "is_gas_error": any(x in err_text for x in ["gas", "out of gas", "intrinsic"]),
+            "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 _decode_revert_reason(self, error: Exception) -> Optional[str]:
+        """Attempt to decode the revert reason."""
+        import re
+
+        error_text = str(error)
+        hex_match = re.search(r"0x[0-9a-fA-F]{8,}", error_text)
+        if hex_match:
+            try:
+                data = hex_match.group(0)
+                decoded = ErrorDecoder().decode(data)
+                if decoded:
+                    name, msg, source = decoded[0]
+                    return f"{msg} (from {source})"
+            except Exception:
+                pass
+        return None
+
+    def _log_retry(self, attempt: int, error: Exception, strategy: str):
+        """Log a retry attempt."""
+        logger.warning(f"Safe TX attempt {attempt} failed, strategy: {strategy}. Error: {error}")

iwa/core/services/transaction.py

@@ -45,19 +45,29 @@ class TransferLogger:
         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)
+                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", "")
+                    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 "")
+                    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 isinstance(receipt, dict) else getattr(receipt, "logs", [])
+        logs = (
+            receipt.get("logs", []) if isinstance(receipt, dict) else getattr(receipt, "logs", [])
+        )
 
         for log in logs:
             self._process_log(log)
@@ -156,7 +166,9 @@ class TransferLogger:
         else:
             # Likely an NFT (ERC721) - the amount is the token ID
             if amount_wei > 0:
-                logger.info(f"[NFT TRANSFER] Token #{amount_wei} {token_label}: {from_label} → {to_label}")
+                logger.info(
+                    f"[NFT TRANSFER] Token #{amount_wei} {token_label}: {from_label} → {to_label}"
+                )
             else:
                 logger.debug(f"[NFT TRANSFER] {token_label}: {from_label} → {to_label}")
 
@@ -265,9 +277,7 @@ class TransactionService:
             """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
-                )
+                txn_hash = chain_interface.web3.eth.send_raw_transaction(signed_txn.raw_transaction)
                 receipt = chain_interface.web3.eth.wait_for_transaction_receipt(txn_hash)
 
                 status = getattr(receipt, "status", None)
@@ -320,6 +330,15 @@ class TransactionService:
 
         if "chainId" not in tx:
             tx["chainId"] = chain_interface.chain.chain_id
+
+        # Safety net: Ensure fees are set if missing (prevents FeeTooLow on Gnosis)
+        if "gasPrice" not in tx and "maxFeePerGas" not in tx:
+            try:
+                fees = chain_interface.get_suggested_fees()
+                tx.update(fees)
+            except Exception as e:
+                logger.debug(f"Failed to auto-fill fees in _prepare_transaction: {e}")
+
         return True
 
     def _handle_gas_retry(self, e: Exception, tx: dict, state: dict) -> None:
@@ -403,10 +422,12 @@ class TransactionService:
         signer_account: StoredSafeAccount,
         chain_interface,
         chain_name: str,
-        tags: List[str] = None
+        tags: List[str] = None,
     ) -> Tuple[bool, Dict]:
         """Execute transaction via SafeService."""
-        logger.info(f"Routing transaction via Safe {self._resolve_label(signer_account.address, chain_name)}...")
+        logger.info(
+            f"Routing transaction via Safe {self._resolve_label(signer_account.address, chain_name)}..."
+        )
 
         try:
             # Extract basic params
@@ -422,10 +443,11 @@ class TransactionService:
                 to=to_addr,
                 value=value,
                 chain_name=chain_name,
-                data=data
+                data=data,
             )
 
-            # Wait for receipt
+            # Receipt is already waited for inside execute_safe_transaction/executor
+            # but we can fetch it again here to be safe and continue with Olas logging
             receipt = chain_interface.web3.eth.wait_for_transaction_receipt(tx_hash)
 
             status = getattr(receipt, "status", None)
@@ -435,7 +457,13 @@ class TransactionService:
             if receipt and status == 1:
                 logger.info(f"Safe transaction executed successfully. Tx Hash: {tx_hash}")
                 self._log_successful_transaction(
-                    receipt, tx, signer_account, chain_name, bytes.fromhex(tx_hash.replace("0x", "")), tags, chain_interface
+                    receipt,
+                    tx,
+                    signer_account,
+                    chain_name,
+                    bytes.fromhex(tx_hash.replace("0x", "")),
+                    tags,
+                    chain_interface,
                 )
                 return True, receipt
             else:
@@ -450,11 +478,13 @@ class TransactionService:
             # Extract hex data from common error patterns
             # Pattern 1: ('execution reverted', '0x...')
             import re
+
             hex_match = re.search(r"0x[0-9a-fA-F]{8,}", error_text)
 
             if hex_match:
                 try:
                     from iwa.core.contracts.decoder import ErrorDecoder
+
                     data = hex_match.group(0)
                     decoded = ErrorDecoder().decode(data)
                     if decoded:

iwa/core/services/transfer/erc20.py

@@ -14,7 +14,6 @@ if TYPE_CHECKING:
     from iwa.core.services.transfer import TransferService
 
 
-
 class ERC20TransferMixin:
     """Mixin for ERC20 token transfers and approvals."""
 
@@ -57,11 +56,23 @@ class ERC20TransferMixin:
             chain_name=chain_name,
             data=transaction["data"],
         )
-        # Get receipt for gas calculation
+        # Get receipt for gas calculation with retry
         receipt = None
         try:
             interface = ChainInterfaces().get(chain_name)
-            receipt = interface.web3.eth.get_transaction_receipt(tx_hash)
+            import time
+
+            for _ in range(5):
+                try:
+                    receipt = interface.web3.eth.get_transaction_receipt(tx_hash)
+                    if receipt:
+                        break
+                except Exception:
+                    pass
+                time.sleep(2)
+
+            if not receipt:
+                logger.warning(f"Could not get receipt for Safe tx {tx_hash} after retries")
         except Exception as e:
             logger.warning(f"Could not get receipt for Safe tx {tx_hash}: {e}")
 

iwa/core/services/transfer/native.py

@@ -85,24 +85,14 @@ class NativeTransferMixin:
     ) -> Optional[str]:
         """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({
+        tx = chain_interface.calculate_transaction_params(
+            built_method=None,
+            tx_params={
                 "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(
@@ -189,17 +179,13 @@ class NativeTransferMixin:
         logger.info(f"Wrapping {amount_eth:.4f} xDAI → WXDAI...")
 
         try:
-            tx = contract.functions.deposit().build_transaction(
-                {
-                    "from": account.address,
-                    "value": amount_wei,
-                    "gas": 100000,
-                    "gasPrice": chain_interface.web3._web3.eth.gas_price,
-                    "nonce": chain_interface.web3._web3.eth.get_transaction_count(account.address),
-                }
+            tx_params = chain_interface.calculate_transaction_params(
+                built_method=contract.functions.deposit(),
+                tx_params={"from": account.address, "value": amount_wei},
             )
+            transaction = contract.functions.deposit().build_transaction(tx_params)
 
-            signed = self.key_storage.sign_transaction(tx, account.address)
+            signed = self.key_storage.sign_transaction(transaction, account.address)
             tx_hash = chain_interface.web3._web3.eth.send_raw_transaction(signed.raw_transaction)
             receipt = chain_interface.web3._web3.eth.wait_for_transaction_receipt(
                 tx_hash, timeout=60
@@ -270,14 +256,11 @@ class NativeTransferMixin:
         logger.info(f"Unwrapping {amount_eth:.4f} WXDAI → xDAI...")
 
         try:
-            tx = contract.functions.withdraw(amount_wei).build_transaction(
-                {
-                    "from": account.address,
-                    "gas": 100000,
-                    "gasPrice": chain_interface.web3._web3.eth.gas_price,
-                    "nonce": chain_interface.web3._web3.eth.get_transaction_count(account.address),
-                }
+            tx_params = chain_interface.calculate_transaction_params(
+                built_method=contract.functions.withdraw(amount_wei),
+                tx_params={"from": account.address},
             )
+            tx = contract.functions.withdraw(amount_wei).build_transaction(tx_params)
 
             signed = self.key_storage.sign_transaction(tx, account.address)
             tx_hash = chain_interface.web3._web3.eth.send_raw_transaction(signed.raw_transaction)

iwa/core/services/transfer/swap.py

@@ -104,6 +104,7 @@ class SwapMixin:
             sell_token_name=sell_token_name,
             buy_token_name=buy_token_name,
             order_type=order_type,
+            wait_for_execution=True,
         )
 
         if result:

iwa/core/tests/test_gnosis_fee.py

@@ -0,0 +1,91 @@
+"""Test Gnosis fee calculation fix."""
+
+import unittest
+from unittest.mock import MagicMock
+
+from iwa.core.chain.interface import ChainInterface
+
+
+class TestGnosisFeeFix(unittest.TestCase):
+    """Test fee calculation for Gnosis chain."""
+
+    def setUp(self):
+        """Set up test fixtures."""
+        self.chain_interface = ChainInterface("gnosis")
+        # Mock web3 to avoid real connection
+        self.chain_interface.web3 = MagicMock()
+        self.chain_interface.web3.eth = MagicMock()
+
+    def test_fee_too_low_fix(self):
+        """Test that maxPriorityFeePerGas is forced to at least 1 wei on Gnosis."""
+        # 1. Setup EIP-1559 environment (block has baseFeePerGas)
+        mock_block = {"baseFeePerGas": 5000}
+        self.chain_interface.web3.eth.get_block.return_value = mock_block
+
+        # 2. Simulate RPC returning 0 priority fee (cause of the error)
+        self.chain_interface.web3.eth.max_priority_fee = 0
+
+        # 3. Setup dummy function for gas estimation
+        mock_func = MagicMock()
+        mock_func.estimate_gas.return_value = 100_000
+
+        # 4. Call calculation
+        tx_params = {"from": "0x123", "value": 0}
+        params = self.chain_interface.calculate_transaction_params(mock_func, tx_params)
+
+        # 5. Verify the fix
+        # Should have EIP-1559 fields
+        self.assertIn("maxFeePerGas", params)
+        self.assertIn("maxPriorityFeePerGas", params)
+        self.assertNotIn("gasPrice", params)
+
+        # CRITICAL ASSERTION: maxPriorityFeePerGas must be >= 1
+        # If the fix works, it should be 1. If it fails (old behavior), it would be 0.
+        self.assertEqual(
+            params["maxPriorityFeePerGas"], 1, "Priority fee should be forced to 1 wei"
+        )
+
+        # Verify max fee calculation: (base * 1.5) + priority
+        expected_max_fee = int(5000 * 1.5) + 1
+        self.assertEqual(params["maxFeePerGas"], expected_max_fee)
+
+    def test_legacy_fallback(self):
+        """Test fallback to legacy gasPrice if baseFeePerGas is missing."""
+        # Setup legacy block (no baseFeePerGas)
+        self.chain_interface.web3.eth.get_block.return_value = {}
+        self.chain_interface.web3.eth.gas_price = 2000000000
+
+        mock_func = MagicMock()
+        mock_func.estimate_gas.return_value = 100_000
+
+        tx_params = {"from": "0x123", "value": 0}
+        params = self.chain_interface.calculate_transaction_params(mock_func, tx_params)
+
+        self.assertIn("gasPrice", params)
+        self.assertNotIn("maxFeePerGas", params)
+        self.assertEqual(params["gasPrice"], 2000000000)
+
+    def test_other_chain_behavior(self):
+        """Test that other chains (e.g. Ethereum) don't necessarily upgrade 0 to 1 (unless generic rule applies)."""
+        # Our fix in interface.py applies the fallback logic:
+        # if max_priority_fee < 1: max_priority_fee = 1
+        # This is now generic in the cleaned up code (lines 449-450: if max_priority_fee < 1: max_priority_fee = 1)
+        # So it should apply to ALL chains that support EIP-1559.
+
+        # We'll use Ethereum to verify generic behavior
+        eth_interface = ChainInterface("ethereum")
+        eth_interface.web3 = MagicMock()
+        eth_interface.web3.eth = MagicMock()
+
+        mock_block = {"baseFeePerGas": 100_000}
+        eth_interface.web3.eth.get_block.return_value = mock_block
+        eth_interface.web3.eth.max_priority_fee = 0
+
+        mock_func = MagicMock()
+        mock_func.estimate_gas.return_value = 21000
+
+        params = eth_interface.calculate_transaction_params(mock_func, {"from": "0x123"})
+
+        self.assertEqual(
+            params["maxPriorityFeePerGas"], 1, "Generic fallback should apply to all chains"
+        )