iwa 0.0.0__py3-none-any.whl → 0.0.1a2__py3-none-any.whl

iwa/core/services/transaction.py

@@ -0,0 +1,172 @@
+"""Transaction service module."""
+
+import time
+from typing import Dict, List, Optional, Tuple
+
+from loguru import logger
+from web3 import exceptions as web3_exceptions
+
+from iwa.core.chain import ChainInterfaces
+from iwa.core.db import log_transaction
+from iwa.core.keys import KeyStorage
+from iwa.core.services.account import AccountService
+
+
+class TransactionService:
+    """Manages transaction lifecycle: signing, sending, retrying."""
+
+    def __init__(self, key_storage: KeyStorage, account_service: AccountService):
+        """Initialize TransactionService."""
+        self.key_storage = key_storage
+        self.account_service = account_service
+
+    def sign_and_send(
+        self,
+        transaction: dict,
+        signer_address_or_tag: str,
+        chain_name: str = "gnosis",
+        tags: Optional[List[str]] = None,
+    ) -> Tuple[bool, Dict]:
+        """Sign and send a transaction with retry logic for gas."""
+        chain_interface = ChainInterfaces().get(chain_name)
+        tx = dict(transaction)
+        max_retries = 3
+
+        if not self._prepare_transaction(tx, signer_address_or_tag, chain_interface):
+            return False, {}
+
+        for attempt in range(1, max_retries + 1):
+            try:
+                signed_txn = self.key_storage.sign_transaction(tx, signer_address_or_tag)
+                txn_hash = chain_interface.web3.eth.send_raw_transaction(signed_txn.raw_transaction)
+                receipt = chain_interface.web3.eth.wait_for_transaction_receipt(txn_hash)
+
+                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
+                    )
+                    return True, receipt
+
+                # Transaction reverted
+                logger.error("Transaction failed (status 0).")
+                return False, {}
+
+            except web3_exceptions.Web3RPCError as e:
+                if self._handle_gas_error(e, tx, attempt, max_retries):
+                    continue
+                return False, {}
+
+            except Exception as e:
+                # Attempt RPC rotation
+                if self._handle_generic_error(e, chain_interface, attempt, max_retries):
+                    continue
+                return False, {}
+
+        return False, {}
+
+    def _prepare_transaction(self, tx: dict, signer_tag: str, chain_interface) -> bool:
+        """Ensure nonce and chainId are set."""
+        if "nonce" not in tx:
+            signer_account = self.account_service.resolve_account(signer_tag)
+            if not signer_account:
+                logger.error(f"Signer {signer_tag} not found")
+                return False
+            tx["nonce"] = chain_interface.web3.eth.get_transaction_count(signer_account.address)
+
+        if "chainId" not in tx:
+            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})..."
+            )
+            current_gas = int(tx.get("gas", 30_000))
+            tx["gas"] = int(current_gas * 1.5)
+            time.sleep(0.5 * attempt)
+            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...")
+                time.sleep(0.5 * attempt)
+                return True
+        logger.exception(f"Unexpected error sending transaction: {e}")
+        return False
+
+    def _log_successful_transaction(self, receipt, tx, signer_account, chain_name, txn_hash, tags):
+        try:
+            gas_cost_wei, gas_value_eur = self._calculate_gas_cost(receipt, tx, chain_name)
+            final_tags = self._determine_tags(tx, tags)
+
+            log_transaction(
+                tx_hash=txn_hash.hex(),
+                from_addr=signer_account.address,
+                to_addr=tx.get("to", ""),
+                token="NATIVE",
+                amount_wei=tx.get("value", 0),
+                chain=chain_name,
+                from_tag=signer_account.tag if hasattr(signer_account, "tag") else None,
+                gas_cost=str(gas_cost_wei) if gas_cost_wei else None,
+                gas_value_eur=gas_value_eur,
+                tags=final_tags if final_tags else None,
+            )
+        except Exception as log_err:
+            logger.warning(f"Failed to log transaction: {log_err}")
+
+    def _calculate_gas_cost(self, receipt, tx, chain_name):
+        gas_used = getattr(receipt, "gasUsed", 0)
+        gas_price = getattr(
+            receipt,
+            "effectiveGasPrice",
+            tx.get("gasPrice", tx.get("maxFeePerGas", 0)),
+        )
+        gas_cost_wei = gas_used * gas_price if gas_price else 0
+
+        gas_value_eur = None
+        if gas_cost_wei > 0:
+            try:
+                from iwa.core.pricing import PriceService
+
+                token_id = "dai" if chain_name.lower() == "gnosis" else "ethereum"
+                pricing = PriceService()
+                native_price = pricing.get_token_price(token_id)
+                if native_price:
+                    gas_eth = float(gas_cost_wei) / 10**18
+                    gas_value_eur = gas_eth * native_price
+            except Exception as price_err:
+                logger.warning(f"Failed to calculate gas value: {price_err}")
+        return gas_cost_wei, gas_value_eur
+
+    def _determine_tags(self, tx, tags):
+        final_tags = tags or []
+        data_hex = tx.get("data", "")
+        if isinstance(data_hex, bytes):
+            data_hex = data_hex.hex()
+        if data_hex.startswith("0x095ea7b3") or data_hex.startswith("095ea7b3"):
+            final_tags.append("approve")
+
+        if "olas" in str(tx.get("to", "")).lower():
+            final_tags.append("olas")
+
+        return list(set(final_tags))
+
+    def _is_gas_too_low_error(self, err_text: str) -> bool:
+        """Check if error is due to low gas."""
+        low_gas_signals = [
+            "feetoolow",
+            "intrinsic gas too low",
+            "replacement transaction underpriced",
+        ]
+        text = (err_text or "").lower()
+        return any(sig in text for sig in low_gas_signals)

iwa/core/services/transfer/__init__.py

@@ -0,0 +1,166 @@
+"""Transfer service package."""
+
+from typing import Optional
+
+from loguru import logger
+from web3.types import Wei
+
+from iwa.core.chain import ChainInterfaces
+from iwa.core.constants import NATIVE_CURRENCY_ADDRESS
+from iwa.core.contracts.erc20 import ERC20Contract
+from iwa.core.contracts.multisend import (
+    MultiSendCallOnlyContract,
+    MultiSendContract,
+)
+from iwa.core.models import StoredSafeAccount
+from iwa.core.services.transfer.base import TransferServiceBase
+from iwa.core.services.transfer.erc20 import ERC20TransferMixin
+from iwa.core.services.transfer.multisend import MultiSendMixin
+from iwa.core.services.transfer.native import NativeTransferMixin
+from iwa.core.services.transfer.swap import SwapMixin
+from iwa.plugins.gnosis.cow import CowSwap, OrderType
+
+__all__ = [
+    "TransferService",
+    # Re-export for backward compatibility
+    "MultiSendCallOnlyContract",
+    "MultiSendContract",
+    "StoredSafeAccount",
+    "CowSwap",
+    "OrderType",
+    "ERC20Contract",
+]
+
+
+class TransferService(
+    NativeTransferMixin, ERC20TransferMixin, MultiSendMixin, SwapMixin, TransferServiceBase
+):
+    """Service for handling transfers, swaps, and approvals.
+
+    Composed of mixins for specific functionalities:
+    - NativeTransferMixin: Native currency transfers and wrapping
+    - ERC20TransferMixin: ERC20 tokens transfers and approvals
+    - MultiSendMixin: Batch transactions and draining
+    - SwapMixin: CowSwap integration
+    - TransferServiceBase: Shared implementations and helpers
+    """
+
+    def send(
+        self,
+        from_address_or_tag: str,
+        to_address_or_tag: str,
+        amount_wei: Wei,
+        token_address_or_name: str = "native",
+        chain_name: str = "gnosis",
+    ) -> Optional[str]:
+        """Send native currency or ERC20 token.
+
+        Args:
+            from_address_or_tag: Source account address or tag
+            to_address_or_tag: Destination address or tag
+            amount_wei: Amount in wei
+            token_address_or_name: Token address, name, or "native"
+            chain_name: Chain name (default: "gnosis")
+
+        Returns:
+            Transaction hash if successful, None otherwise.
+
+        """
+        # Resolve accounts
+        from_account = self.account_service.resolve_account(from_address_or_tag)
+        if not from_account:
+            logger.error(f"From account '{from_address_or_tag}' not found in wallet.")
+            return None
+
+        to_address, to_tag = self._resolve_destination(to_address_or_tag)
+        if not to_address:
+            return None
+
+        # SECURITY: Validate destination is whitelisted
+        if not self._is_whitelisted_destination(to_address):
+            return None
+
+        # SECURITY: Validate token is supported
+        if not self._is_supported_token(token_address_or_name, chain_name):
+            return None
+
+        # Resolve chain and token
+        chain_interface = ChainInterfaces().get(chain_name)
+        token_address = self.account_service.get_token_address(
+            token_address_or_name, chain_interface.chain
+        )
+        if not token_address:
+            return None
+
+        # Resolve tags and symbols for logging
+        from_tag = self.account_service.get_tag_by_address(from_account.address)
+        token_symbol = self._resolve_token_symbol(
+            token_address, token_address_or_name, chain_interface
+        )
+        is_safe = getattr(from_account, "threshold", None) is not None
+
+        # Native currency transfer
+        if token_address == NATIVE_CURRENCY_ADDRESS:
+            amount_eth = float(chain_interface.web3.from_wei(amount_wei, "ether"))
+            logger.info(
+                f"Sending {amount_eth:.4f} {chain_interface.chain.native_currency} "
+                f"from {from_address_or_tag} to {to_address_or_tag}"
+            )
+            if is_safe:
+                return self._send_native_via_safe(
+                    from_account,
+                    from_address_or_tag,
+                    to_address,
+                    amount_wei,
+                    chain_name,
+                    from_tag,
+                    to_tag,
+                    token_symbol,
+                )
+            return self._send_native_via_eoa(
+                from_account,
+                to_address,
+                amount_wei,
+                chain_name,
+                chain_interface,
+                from_tag,
+                to_tag,
+                token_symbol,
+            )
+
+        # ERC20 token transfer
+        erc20 = ERC20Contract(token_address, chain_name)
+        transaction = erc20.prepare_transfer_tx(from_account.address, to_address, amount_wei)
+        if not transaction:
+            return None
+
+        amount_eth = float(chain_interface.web3.from_wei(amount_wei, "ether"))
+        logger.info(
+            f"Sending {amount_eth:.4f} {token_address_or_name} "
+            f"from {from_address_or_tag} to {to_address_or_tag}"
+        )
+
+        if is_safe:
+            return self._send_erc20_via_safe(
+                from_account,
+                from_address_or_tag,
+                to_address,
+                amount_wei,
+                chain_name,
+                erc20,
+                transaction,
+                from_tag,
+                to_tag,
+                token_symbol,
+            )
+        return self._send_erc20_via_eoa(
+            from_account,
+            from_address_or_tag,
+            to_address,
+            amount_wei,
+            chain_name,
+            transaction,
+            from_tag,
+            to_tag,
+            token_symbol,
+        )

iwa/core/services/transfer/base.py

@@ -0,0 +1,260 @@
+"""Transfer service base module."""
+
+from typing import TYPE_CHECKING, Optional
+
+from loguru import logger
+from web3.types import Wei
+
+from iwa.core.chain import ChainInterfaces
+from iwa.core.constants import NATIVE_CURRENCY_ADDRESS
+from iwa.core.models import Config, EthereumAddress
+from iwa.core.pricing import PriceService
+
+if TYPE_CHECKING:
+    from iwa.core.keys import KeyStorage
+    from iwa.core.services.account import AccountService
+    from iwa.core.services.balance import BalanceService
+    from iwa.core.services.safe import SafeService
+    from iwa.core.services.transaction import TransactionService
+
+
+# Coingecko IDs for tokens and native currencies
+TOKEN_COINGECKO_IDS = {
+    "XDAI": "xdai",
+    "ETH": "ethereum",
+    "OLAS": "autonolas",
+    "USDC": "usdc",
+    "WXDAI": "xdai",
+    "SDAI": "savings-xdai",
+    "EURE": "monerium-eur-money",
+}
+
+CHAIN_COINGECKO_IDS = {
+    "gnosis": "dai",
+    "ethereum": "ethereum",
+    "base": "ethereum",
+}
+
+
+class TransferServiceBase:
+    """Base class for TransferService with shared helpers."""
+
+    def __init__(
+        self,
+        key_storage: "KeyStorage",
+        account_service: "AccountService",
+        balance_service: "BalanceService",
+        safe_service: "SafeService",
+        transaction_service: "TransactionService",
+    ):
+        """Initialize TransferService."""
+        self.key_storage = key_storage
+        self.account_service = account_service
+        self.balance_service = balance_service
+        self.safe_service = safe_service
+        self.transaction_service = transaction_service
+
+    def _resolve_destination(self, to_address_or_tag: str) -> tuple[Optional[str], Optional[str]]:
+        """Resolve destination address and tag.
+
+        Returns:
+            Tuple of (address, tag) or (None, None) if invalid.
+
+        """
+        to_account = self.account_service.resolve_account(to_address_or_tag)
+        if to_account:
+            return to_account.address, getattr(to_account, "tag", None)
+
+        try:
+            to_address = EthereumAddress(to_address_or_tag)
+            # Try to find tag in whitelist
+            to_tag = self._resolve_whitelist_tag(to_address)
+            return to_address, to_tag
+        except ValueError:
+            logger.error(f"Invalid destination address: {to_address_or_tag}")
+            return None, None
+
+    def _resolve_whitelist_tag(self, address: str) -> Optional[str]:
+        """Resolve tag from whitelist for an address."""
+        config = Config()
+        if config.core and config.core.whitelist:
+            try:
+                target_addr = EthereumAddress(address)
+                for name, addr in config.core.whitelist.items():
+                    if addr == target_addr:
+                        return name
+            except ValueError:
+                pass
+        return None
+
+    def _calculate_gas_info(
+        self, receipt: Optional[dict], chain_name: str
+    ) -> tuple[Optional[int], Optional[float]]:
+        """Calculate gas cost and gas value in EUR from transaction receipt.
+
+        Args:
+            receipt: Transaction receipt containing gasUsed and effectiveGasPrice.
+            chain_name: Name of the chain for price lookup.
+
+        Returns:
+            Tuple of (gas_cost_wei, gas_value_eur) or (None, None) if unavailable.
+
+        """
+        if not receipt:
+            return None, None
+
+        try:
+            gas_used = receipt.get("gasUsed", 0)
+            effective_gas_price = receipt.get("effectiveGasPrice", 0)
+            gas_cost_wei = gas_used * effective_gas_price
+
+            # Get native token price
+            coingecko_id = CHAIN_COINGECKO_IDS.get(chain_name, "ethereum")
+            price_service = PriceService()
+            native_price_eur = price_service.get_token_price(coingecko_id, "eur")
+
+            gas_value_eur = None
+            if native_price_eur and gas_cost_wei > 0:
+                gas_cost_eth = gas_cost_wei / 10**18
+                gas_value_eur = gas_cost_eth * native_price_eur
+
+            return gas_cost_wei, gas_value_eur
+        except Exception as e:
+            logger.warning(f"Failed to calculate gas info: {e}")
+            return None, None
+
+    def _get_token_price_info(
+        self, token_symbol: str, amount_wei: Wei, chain_name: str
+    ) -> tuple[Optional[float], Optional[float]]:
+        """Calculate token price and total value in EUR.
+
+        Args:
+            token_symbol: Token symbol (e.g. 'OLAS', 'ETH')
+            amount_wei: Amount in wei
+            chain_name: Chain name
+
+        Returns:
+            Tuple of (price_eur, value_eur) or (None, None) if unavailable.
+
+        """
+        try:
+            # Map symbol to coingecko id
+            symbol_upper = token_symbol.upper()
+            cg_id = TOKEN_COINGECKO_IDS.get(symbol_upper)
+            if not cg_id:
+                # Try name mapping if it's native signal
+                if symbol_upper in ["NATIVE", "TOKEN"]:
+                    cg_id = CHAIN_COINGECKO_IDS.get(chain_name.lower())
+
+            if not cg_id:
+                return None, None
+
+            price_service = PriceService()
+            price_eur = price_service.get_token_price(cg_id, "eur")
+
+            if price_eur is None:
+                return None, None
+
+            # Get decimals for value calculation
+            interface = ChainInterfaces().get(chain_name)
+            decimals = 18
+            if symbol_upper not in ["NATIVE", "TOKEN", "XDAI", "ETH"]:
+                token_address = interface.chain.get_token_address(token_symbol)
+                if token_address:
+                    decimals = interface.get_token_decimals(token_address)
+
+            value_eur = (amount_wei / 10**decimals) * price_eur
+            return price_eur, value_eur
+        except Exception as e:
+            logger.warning(f"Failed to calculate token price info for {token_symbol}: {e}")
+            return None, None
+
+    def _is_whitelisted_destination(self, to_address: str) -> bool:
+        """Check if destination address is whitelisted.
+
+        An address is whitelisted if it's:
+        1. One of our own accounts (from wallets.json)
+        2. In the explicit whitelist in config.yaml [core.whitelist]
+
+        Returns:
+            True if allowed, False if blocked.
+
+        """
+        # Normalize address for comparison
+        try:
+            target_addr = EthereumAddress(to_address)
+        except ValueError:
+            logger.error(f"Invalid address format: {to_address}")
+            return False
+
+        # Check 1: Is it one of our own wallets?
+        if self.account_service.resolve_account(to_address):
+            return True
+
+        # Check 2: Is it in the config whitelist?
+        config = Config()
+        if config.core and config.core.whitelist:
+            if target_addr in config.core.whitelist.values():
+                return True
+
+        # Not in whitelist - block transaction
+        logger.error(
+            f"SECURITY: Destination {to_address} is NOT whitelisted. "
+            "Transaction blocked. Add to config.yaml [core.whitelist] to allow."
+        )
+        return False
+
+    def _is_supported_token(self, token_address_or_name: str, chain_name: str) -> bool:
+        """Validate that the token is supported on this chain.
+
+        Supported tokens are:
+        1. Native currency
+        2. Tokens defined in chain.tokens (defaults + custom_tokens)
+
+        Returns:
+            True if token is supported, False otherwise.
+
+        """
+        # Native currency is always allowed
+        if token_address_or_name.lower() in ("native", NATIVE_CURRENCY_ADDRESS.lower()):
+            return True
+
+        chain_interface = ChainInterfaces().get(chain_name)
+        supported_tokens = chain_interface.tokens
+
+        # Check by name (e.g., "OLAS")
+        if token_address_or_name.upper() in supported_tokens:
+            return True
+
+        # Check by address
+        try:
+            token_addr = EthereumAddress(token_address_or_name)
+            if token_addr in supported_tokens.values():
+                return True
+        except ValueError:
+            pass  # Not a valid address, already checked by name
+
+        # Token not supported
+        supported_list = ", ".join(supported_tokens.keys())
+        logger.error(
+            f"SECURITY: Token '{token_address_or_name}' is NOT supported on {chain_name}. "
+            f"Supported tokens: {supported_list}. "
+            "Add to config.yaml [core.custom_tokens] to allow."
+        )
+        return False
+
+    def _resolve_token_symbol(
+        self, token_address: str, token_address_or_name: str, chain_interface
+    ) -> str:
+        """Resolve token symbol for logging."""
+        if token_address == NATIVE_CURRENCY_ADDRESS:
+            return chain_interface.chain.native_currency
+
+        if not token_address_or_name.startswith("0x"):
+            return token_address_or_name
+
+        for name, addr in chain_interface.tokens.items():
+            if addr == token_address:
+                return name
+
+        return token_address_or_name