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

iwa/core/services/transfer/native.py

@@ -0,0 +1,262 @@
+"""Native transfer mixin."""
+
+from typing import TYPE_CHECKING, Optional
+
+from loguru import logger
+from web3 import Web3
+from web3.types import Wei
+
+from iwa.core.chain import ChainInterfaces
+from iwa.core.db import log_transaction
+from iwa.core.models import StoredSafeAccount
+
+if TYPE_CHECKING:
+    from iwa.core.services.transfer import TransferService
+
+
+class NativeTransferMixin:
+    """Mixin for native currency transfers and wrapping."""
+
+    def _send_native_via_safe(
+        self: "TransferService",
+        from_account: StoredSafeAccount,
+        from_address_or_tag: str,
+        to_address: str,
+        amount_wei: Wei,
+        chain_name: str,
+        from_tag: Optional[str],
+        to_tag: Optional[str],
+        token_symbol: str,
+    ) -> str:
+        """Send native currency via Safe multisig."""
+        tx_hash = self.safe_service.execute_safe_transaction(
+            safe_address_or_tag=from_address_or_tag,
+            to=to_address,
+            value=amount_wei,
+            chain_name=chain_name,
+        )
+        # Get receipt for gas calculation
+        receipt = None
+        try:
+            interface = ChainInterfaces().get(chain_name)
+            receipt = interface.web3.eth.get_transaction_receipt(tx_hash)
+        except Exception as e:
+            logger.warning(f"Could not get receipt for Safe tx {tx_hash}: {e}")
+
+        gas_cost, gas_value_eur = self._calculate_gas_info(receipt, chain_name)
+        # Get price and value
+        p_eur, v_eur = self._get_token_price_info(token_symbol, amount_wei, chain_name)
+        log_transaction(
+            tx_hash=tx_hash,
+            from_addr=from_account.address,
+            to_addr=to_address,
+            token=token_symbol,
+            amount_wei=amount_wei,
+            chain=chain_name,
+            from_tag=from_tag,
+            to_tag=to_tag,
+            gas_cost=gas_cost,
+            gas_value_eur=gas_value_eur,
+            price_eur=p_eur,
+            value_eur=v_eur,
+            tags=["native-transfer", "safe-transaction"],
+        )
+        return tx_hash
+
+    def _send_native_via_eoa(
+        self: "TransferService",
+        from_account,
+        to_address: str,
+        amount_wei: Wei,
+        chain_name: str,
+        chain_interface,
+        from_tag: Optional[str],
+        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),
+        )
+        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}")
+
+            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)
+            log_transaction(
+                tx_hash=tx_hash,
+                from_addr=from_account.address,
+                to_addr=to_address,
+                token=token_symbol,
+                amount_wei=amount_wei,
+                chain=chain_name,
+                from_tag=from_tag,
+                to_tag=to_tag,
+                gas_cost=gas_cost,
+                gas_value_eur=gas_value_eur,
+                price_eur=p_eur,
+                value_eur=v_eur,
+                tags=["native-transfer"],
+            )
+            return tx_hash
+        return None
+
+    def wrap_native(
+        self: "TransferService",
+        account_address_or_tag: str,
+        amount_wei: Wei,
+        chain_name: str = "gnosis",
+    ) -> Optional[str]:
+        """Wrap native currency to wrapped token (e.g., xDAI → WXDAI).
+
+        Args:
+            account_address_or_tag: Account to wrap from
+            amount_wei: Amount in wei to wrap
+            chain_name: Chain name (default: gnosis)
+
+        Returns:
+            Transaction hash if successful, None otherwise.
+
+        """
+        account = self.account_service.resolve_account(account_address_or_tag)
+        if not account:
+            logger.error(f"Account '{account_address_or_tag}' not found.")
+            return None
+
+        chain_interface = ChainInterfaces().get(chain_name)
+        wrapped_token = chain_interface.chain.tokens.get("WXDAI")
+        if not wrapped_token:
+            logger.error(f"WXDAI not found on {chain_name}")
+            return None
+
+        # Simple WETH ABI for deposit
+        weth_abi = [
+            {
+                "constant": False,
+                "inputs": [],
+                "name": "deposit",
+                "outputs": [],
+                "payable": True,
+                "type": "function",
+            }
+        ]
+
+        contract = chain_interface.web3._web3.eth.contract(address=wrapped_token, abi=weth_abi)
+
+        amount_eth = float(Web3.from_wei(amount_wei, "ether"))
+        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),
+                }
+            )
+
+            signed = self.key_storage.sign_transaction(tx, 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
+            )
+
+            if receipt.status == 1:
+                logger.info(f"Wrap successful! TX: {tx_hash.hex()}")
+                return tx_hash.hex()
+            else:
+                logger.error(f"Wrap failed. TX: {tx_hash.hex()}")
+                return None
+        except Exception as e:
+            logger.error(f"Error wrapping: {e}")
+            return None
+
+    def unwrap_native(
+        self: "TransferService",
+        account_address_or_tag: str,
+        amount_wei: Optional[Wei] = None,
+        chain_name: str = "gnosis",
+    ) -> Optional[str]:
+        """Unwrap wrapped token to native currency (e.g., WXDAI → xDAI).
+
+        Args:
+            account_address_or_tag: Account to unwrap from
+            amount_wei: Amount in wei to unwrap (None = all balance)
+            chain_name: Chain name (default: gnosis)
+
+        Returns:
+            Transaction hash if successful, None otherwise.
+
+        """
+        account = self.account_service.resolve_account(account_address_or_tag)
+        if not account:
+            logger.error(f"Account '{account_address_or_tag}' not found.")
+            return None
+
+        chain_interface = ChainInterfaces().get(chain_name)
+        wrapped_token = chain_interface.chain.tokens.get("WXDAI")
+        if not wrapped_token:
+            logger.error(f"WXDAI not found on {chain_name}")
+            return None
+
+        # Get balance if amount not specified
+        if amount_wei is None:
+            amount_wei = self.balance_service.get_erc20_balance_wei(
+                account.address, "WXDAI", chain_name
+            )
+            if not amount_wei or amount_wei == 0:
+                logger.warning("No WXDAI balance to unwrap")
+                return None
+
+        # Simple WETH ABI for withdraw
+        weth_abi = [
+            {
+                "constant": False,
+                "inputs": [{"name": "wad", "type": "uint256"}],
+                "name": "withdraw",
+                "outputs": [],
+                "payable": False,
+                "type": "function",
+            }
+        ]
+
+        contract = chain_interface.web3._web3.eth.contract(address=wrapped_token, abi=weth_abi)
+
+        amount_eth = float(Web3.from_wei(amount_wei, "ether"))
+        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),
+                }
+            )
+
+            signed = self.key_storage.sign_transaction(tx, 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
+            )
+
+            if receipt.status == 1:
+                logger.info(f"Unwrap successful! TX: {tx_hash.hex()}")
+                return tx_hash.hex()
+            else:
+                logger.error(f"Unwrap failed. TX: {tx_hash.hex()}")
+                return None
+        except Exception as e:
+            logger.error(f"Error unwrapping: {e}")
+            return None

iwa/core/services/transfer/swap.py

@@ -0,0 +1,326 @@
+"""Swap mixin module."""
+
+from typing import TYPE_CHECKING, Any, Optional
+
+from loguru import logger
+from web3 import Web3
+
+from iwa.core.chain import ChainInterfaces
+from iwa.core.contracts.erc20 import ERC20Contract
+from iwa.core.db import log_transaction
+from iwa.plugins.gnosis.cow import COWSWAP_GPV2_VAULT_RELAYER_ADDRESS, CowSwap, OrderType
+
+if TYPE_CHECKING:
+    from iwa.core.services.transfer import TransferService
+
+
+class SwapMixin:
+    """Mixin for token swaps."""
+
+    async def swap(
+        self: "TransferService",
+        account_address_or_tag: str,
+        amount_eth: Optional[float],
+        sell_token_name: str,
+        buy_token_name: str,
+        chain_name: str = "gnosis",
+        order_type: OrderType = OrderType.SELL,
+    ) -> Optional[dict]:
+        """Swap ERC-20 tokens on CowSwap.
+
+        Returns:
+            dict | None: The executed order data if successful, None otherwise.
+
+        """
+        amount_wei = self._prepare_swap_amount(
+            account_address_or_tag,
+            amount_eth,
+            sell_token_name,
+            buy_token_name,
+            chain_name,
+            order_type,
+        )
+        if amount_wei is None:
+            return None
+
+        chain = ChainInterfaces().get(chain_name).chain
+        account = self.account_service.resolve_account(account_address_or_tag)
+
+        # Validate balance before proceeding (for SELL orders)
+        if order_type == OrderType.SELL:
+            current_balance = self.balance_service.get_erc20_balance_wei(
+                account_address_or_tag, sell_token_name, chain_name
+            )
+            if current_balance is not None and current_balance < amount_wei:
+                # Precision tolerance: if the discrepancy is tiny (e.g. < 0.0001 tokens),
+                # just use the actual balance instead of failing.
+                # This handles float precision issues from the frontend.
+                diff = amount_wei - current_balance
+                tolerance = 10**14  # 0.0001 tokens (handles most rounding issues)
+
+                if diff <= tolerance:
+                    logger.warning(
+                        f"Adjusting swap amount due to precision discrepancy: "
+                        f"requested {amount_wei}, balance {current_balance} (diff: {diff})"
+                    )
+                    amount_wei = current_balance
+                else:
+                    balance_eth = current_balance / 1e18
+                    amount_eth_val = amount_wei / 1e18
+                    raise ValueError(
+                        f"Insufficient {sell_token_name} balance: have {balance_eth:.6f}, need {amount_eth_val:.6f}"
+                    )
+            elif current_balance is None:
+                raise ValueError(f"Could not retrieve balance for {sell_token_name}")
+
+        # Get signer (LocalAccount)
+        signer = self.key_storage.get_signer(account.address)
+        if not signer:
+            logger.error(f"Could not retrieve signer for {account_address_or_tag}")
+            return None
+
+        cow = CowSwap(
+            private_key_or_signer=signer,
+            chain=chain,
+        )
+
+        # Check and approve allowance if needed
+        await self._ensure_allowance_for_swap(
+            account_address_or_tag,
+            sell_token_name,
+            buy_token_name,
+            chain_name,
+            amount_wei,
+            order_type,
+            cow,
+        )
+
+        # Execute Swap
+        logger.debug(
+            f"Executing swap: amount_wei={amount_wei}, sell={sell_token_name}, buy={buy_token_name}, order_type={order_type}"
+        )
+        result = await cow.swap(
+            amount_wei=amount_wei,
+            sell_token_name=sell_token_name,
+            buy_token_name=buy_token_name,
+            order_type=order_type,
+        )
+
+        if result:
+            logger.info("Swap successful")
+
+            # Log transaction and analytics
+            try:
+                analytics = self._calculate_swap_analytics(
+                    result, sell_token_name, buy_token_name, chain_name
+                )
+
+                tx_hash = result.get("txHash") or result.get("uid")
+                if tx_hash:
+                    self._log_swap_transaction(
+                        tx_hash,
+                        account,
+                        account_address_or_tag,
+                        sell_token_name,
+                        buy_token_name,
+                        result,
+                        chain_name,
+                        analytics,
+                    )
+
+                # Inject analytics back into result for API/Frontend
+                result["analytics"] = analytics
+
+            except Exception as log_err:
+                logger.warning(f"Failed to log swap analytics: {log_err}")
+
+            return result
+
+        logger.error("Swap failed")
+        return None
+
+    def _prepare_swap_amount(
+        self: "TransferService",
+        account_address_or_tag: str,
+        amount_eth: Optional[float],
+        sell_token_name: str,
+        buy_token_name: str,
+        chain_name: str,
+        order_type: OrderType,
+    ) -> Optional[int]:
+        """Calculate and validate the swap amount in wei."""
+        if amount_eth is None:
+            if order_type == OrderType.BUY:
+                # raise ValueError("Amount must be specified for buy orders.")
+                # To maintain existing behavior (exception raised in original code),
+                # we can either raise or let the caller handle None.
+                # Original raised ValueError, let's keep it safe or just return.
+                # Since original code raised it inside the method, let's raise it here.
+                raise ValueError("Amount must be specified for buy orders.")
+
+            logger.info(f"Swapping entire {sell_token_name} balance to {buy_token_name}")
+            return self.balance_service.get_erc20_balance_wei(
+                account_address_or_tag, sell_token_name, chain_name
+            )
+        else:
+            # Get decimals correctly!
+            decimals = 18
+            try:
+                chain_interface = ChainInterfaces().get(chain_name)
+                token_addr = chain_interface.chain.get_token_address(sell_token_name)
+                if token_addr:
+                    checksum_addr = Web3.to_checksum_address(token_addr)
+                    decimals = ERC20Contract(checksum_addr, chain_name).decimals
+            except Exception as e:
+                logger.warning(f"Could not get decimals for {sell_token_name}, assuming 18: {e}")
+
+            return int(amount_eth * (10**decimals))
+
+    async def _ensure_allowance_for_swap(
+        self: "TransferService",
+        account_address_or_tag: str,
+        sell_token_name: str,
+        buy_token_name: str,
+        chain_name: str,
+        amount_wei: int,
+        order_type: OrderType,
+        cow: CowSwap,
+    ) -> int:
+        """Check and approve allowance for CowSwap."""
+        # Check current allowance first
+        current_allowance = (
+            self.get_erc20_allowance(
+                owner_address_or_tag=account_address_or_tag,
+                spender_address=COWSWAP_GPV2_VAULT_RELAYER_ADDRESS,
+                token_address_or_name=sell_token_name,
+                chain_name=chain_name,
+            )
+            or 0
+        )
+
+        # Calculate required amount
+        if order_type == OrderType.SELL:
+            required_amount = amount_wei
+        else:
+            # Need token addresses for buy mode calculation
+            chain_interface = ChainInterfaces().get(chain_name)
+            sell_token_address = chain_interface.chain.get_token_address(sell_token_name)
+            buy_token_address = chain_interface.chain.get_token_address(buy_token_name)
+            required_amount = await cow.get_max_sell_amount_wei(
+                amount_wei,
+                sell_token_address,
+                buy_token_address,
+            )
+
+        # If allowance is insufficient, approve EXACT amount (No Infinite)
+        if current_allowance < required_amount:
+            logger.info(
+                f"Insufficient allowance ({current_allowance} < {required_amount}). Approving EXACT amount."
+            )
+            self.approve_erc20(
+                owner_address_or_tag=account_address_or_tag,
+                spender_address_or_tag=COWSWAP_GPV2_VAULT_RELAYER_ADDRESS,
+                token_address_or_name=sell_token_name,
+                amount_wei=required_amount,
+                chain_name=chain_name,
+            )
+        else:
+            logger.info(
+                f"Allowance sufficient ({current_allowance} >= {required_amount}). Skipping approval."
+            )
+        return required_amount
+
+    def _calculate_swap_analytics(
+        self: "TransferService",
+        result: dict,
+        sell_token_name: str,
+        buy_token_name: str,
+        chain_name: str,
+    ) -> dict:
+        """Calculate swap analytics from result."""
+        executed_sell = float(result.get("executedSellAmount", 0))
+        executed_buy = float(result.get("executedBuyAmount", 0))
+        quote = result.get("quote", {})
+        sell_price_usd = float(quote.get("sellTokenPrice", 0) or 0)
+        buy_price_usd = float(quote.get("buyTokenPrice", 0) or 0)
+
+        # Calculate Analytics
+        execution_price = 0.0
+        if executed_sell > 0:
+            execution_price = executed_buy / executed_sell  # Raw ratio
+
+        # Get actual token decimals
+        sell_decimals = 18
+        buy_decimals = 18
+        try:
+            chain_interface = ChainInterfaces().get(chain_name)
+            if chain_interface:
+                sell_addr = chain_interface.chain.get_token_address(sell_token_name)
+                buy_addr = chain_interface.chain.get_token_address(buy_token_name)
+                if sell_addr:
+                    sell_decimals = ERC20Contract(
+                        Web3.to_checksum_address(sell_addr), chain_name
+                    ).decimals
+                if buy_addr:
+                    buy_decimals = ERC20Contract(
+                        Web3.to_checksum_address(buy_addr), chain_name
+                    ).decimals
+        except Exception as e:
+            logger.warning(f"Could not get decimals for analytics: {e}")
+
+        value_sold = (executed_sell / (10**sell_decimals)) * sell_price_usd
+        value_bought = (executed_buy / (10**buy_decimals)) * buy_price_usd
+
+        value_change_pct = None
+        if value_sold > 0 and buy_price_usd > 0:
+            value_change_pct = ((value_bought - value_sold) / value_sold) * 100
+
+        # Prepare extra_data
+        return {
+            "type": "swap",
+            "platform": "cowswap",
+            "sell_token": sell_token_name,
+            "buy_token": buy_token_name,
+            "executed_sell_amount": executed_sell,
+            "executed_buy_amount": executed_buy,
+            "sell_price_usd": sell_price_usd,
+            "buy_price_usd": buy_price_usd,
+            "execution_price": execution_price,
+            "value_change_pct": value_change_pct if value_change_pct is not None else "N/A",
+            # Internal fields for logging use
+            "_value_sold": value_sold,
+        }
+
+    def _log_swap_transaction(
+        self,
+        tx_hash: str,
+        account: Any,
+        account_tag: str,
+        sell_token: str,
+        buy_token: str,
+        result: dict,
+        chain_name: str,
+        analytics: dict,
+    ) -> None:
+        """Log swap transaction to database."""
+        executed_sell = float(result.get("executedSellAmount", 0))
+        value_sold = analytics.get("_value_sold", 0.0)
+
+        # Clean internal fields
+        clean_analytics = analytics.copy()
+        clean_analytics.pop("_value_sold", None)
+
+        log_transaction(
+            tx_hash=tx_hash,
+            from_addr=account.address,
+            to_addr=COWSWAP_GPV2_VAULT_RELAYER_ADDRESS,
+            token=sell_token,
+            amount_wei=int(executed_sell),
+            chain=chain_name,
+            from_tag=account_tag,
+            tags=["swap", "cowswap", sell_token, buy_token],
+            gas_cost="0",
+            gas_value_eur=0.0,
+            value_eur=float(value_sold) if value_sold > 0 else None,
+            extra_data=clean_analytics,
+        )

iwa/core/settings.py

@@ -0,0 +1,95 @@
+"""Configuration settings module."""
+
+import os
+from typing import Optional
+
+from dotenv import load_dotenv
+from pydantic import ConfigDict, SecretStr, model_validator
+from pydantic_settings import BaseSettings
+
+from iwa.core.constants import SECRETS_PATH
+from iwa.core.utils import singleton
+
+
+@singleton
+class Settings(BaseSettings):
+    """Application Settings loaded from environment and secrets file."""
+
+    # Testing mode - when True, uses Tenderly test RPCs; when False, uses production RPCs
+    testing: bool = True
+
+    # RPC endpoints (loaded from gnosis_rpc/ethereum_rpc/base_rpc in secrets.env)
+    # When testing=True, these get overwritten with *_test_rpc values
+    gnosis_rpc: Optional[SecretStr] = None
+    base_rpc: Optional[SecretStr] = None
+    ethereum_rpc: Optional[SecretStr] = None
+
+    # Test RPCs
+    gnosis_test_rpc: Optional[SecretStr] = None
+    ethereum_test_rpc: Optional[SecretStr] = None
+    base_test_rpc: Optional[SecretStr] = None
+
+    gnosisscan_api_key: Optional[SecretStr] = None
+    coingecko_api_key: Optional[SecretStr] = None
+    wallet_password: Optional[SecretStr] = None
+    security_word: Optional[SecretStr] = None
+
+    # Tenderly profile (1 or 2) - determines which credentials to load
+    tenderly_profile: int = 1
+
+    # Tenderly credentials - loaded dynamically based on profile
+    tenderly_account_slug: Optional[SecretStr] = None
+    tenderly_project_slug: Optional[SecretStr] = None
+    tenderly_access_key: Optional[SecretStr] = None
+
+    # Tenderly funding configuration
+    tenderly_native_funds: float = 1000.0
+    tenderly_olas_funds: float = 100000.0
+
+    web_enabled: bool = False
+    web_port: int = 8080
+    webui_password: Optional[SecretStr] = None
+
+    model_config = ConfigDict(env_file=str(SECRETS_PATH), env_file_encoding="utf-8", extra="ignore")
+
+    def __init__(self, **values):
+        """Initialize Settings and load environment variables."""
+        # Force load dotenv to ensure os.environ variables are set
+        load_dotenv(SECRETS_PATH, override=True)
+        super().__init__(**values)
+
+    @model_validator(mode="after")
+    def load_tenderly_profile_credentials(self) -> "Settings":
+        """Load Tenderly credentials based on the selected profile."""
+        profile = self.tenderly_profile
+
+        # Load profile-specific credentials from environment
+        account = os.getenv(f"tenderly_account_slug_{profile}")
+        project = os.getenv(f"tenderly_project_slug_{profile}")
+        access_key = os.getenv(f"tenderly_access_key_{profile}")
+
+        if account:
+            self.tenderly_account_slug = SecretStr(account)
+        if project:
+            self.tenderly_project_slug = SecretStr(project)
+        if access_key:
+            self.tenderly_access_key = SecretStr(access_key)
+
+        # When in testing mode, override RPCs with test RPCs (Tenderly)
+        if self.testing:
+            if self.gnosis_test_rpc:
+                self.gnosis_rpc = self.gnosis_test_rpc
+            if self.ethereum_test_rpc:
+                self.ethereum_rpc = self.ethereum_test_rpc
+            if self.base_test_rpc:
+                self.base_rpc = self.base_test_rpc
+
+        # Convert empty webui_password to None (no auth required)
+        if self.webui_password and not self.webui_password.get_secret_value():
+            self.webui_password = None
+
+        return self
+
+
+# Global settings instance
+settings = Settings()