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

iwa/core/services/transfer/erc20.py

@@ -0,0 +1,247 @@
+"""ERC20 transfer mixin."""
+
+from typing import TYPE_CHECKING, Optional
+
+from loguru import logger
+from web3.types import Wei
+
+from iwa.core.chain import ChainInterfaces
+from iwa.core.contracts.erc20 import ERC20Contract
+from iwa.core.db import log_transaction
+from iwa.core.models import StoredSafeAccount
+
+if TYPE_CHECKING:
+    from iwa.core.services.transfer import TransferService
+
+
+class ERC20TransferMixin:
+    """Mixin for ERC20 token transfers and approvals."""
+
+    def _send_erc20_via_safe(
+        self: "TransferService",
+        from_account: StoredSafeAccount,
+        from_address_or_tag: str,
+        to_address: str,
+        amount_wei: Wei,
+        chain_name: str,
+        erc20: ERC20Contract,
+        transaction: dict,
+        from_tag: Optional[str],
+        to_tag: Optional[str],
+        token_symbol: str,
+    ) -> str:
+        """Send ERC20 token via Safe multisig."""
+        tx_hash = self.safe_service.execute_safe_transaction(
+            safe_address_or_tag=from_address_or_tag,
+            to=erc20.address,
+            value=0,
+            chain_name=chain_name,
+            data=transaction["data"],
+        )
+        # 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=["erc20-transfer", "safe-transaction"],
+        )
+        return tx_hash
+
+    def _send_erc20_via_eoa(
+        self: "TransferService",
+        from_account,
+        from_address_or_tag: str,
+        to_address: str,
+        amount_wei: Wei,
+        chain_name: str,
+        transaction: dict,
+        from_tag: Optional[str],
+        to_tag: Optional[str],
+        token_symbol: str,
+    ) -> Optional[str]:
+        """Send ERC20 token via EOA (externally owned account)."""
+        success, receipt = self.transaction_service.sign_and_send(
+            transaction, from_address_or_tag, chain_name
+        )
+        if success and receipt:
+            tx_hash = receipt["transactionHash"].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)
+            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=["erc20-transfer"],
+            )
+            return tx_hash
+        return None
+
+    def get_erc20_allowance(
+        self: "TransferService",
+        owner_address_or_tag: str,
+        spender_address: str,
+        token_address_or_name: str,
+        chain_name: str = "gnosis",
+    ) -> Optional[float]:
+        """Get ERC20 token allowance."""
+        chain = ChainInterfaces().get(chain_name)
+
+        token_address = self.account_service.get_token_address(token_address_or_name, chain.chain)
+        if not token_address:
+            return None
+
+        owner_account = self.account_service.resolve_account(owner_address_or_tag)
+        if not owner_account:
+            return None
+
+        contract = ERC20Contract(chain_name=chain_name, address=token_address)
+        return contract.allowance_wei(owner_account.address, spender_address)
+
+    def approve_erc20(
+        self: "TransferService",
+        owner_address_or_tag: str,
+        spender_address_or_tag: str,
+        token_address_or_name: str,
+        amount_wei: Wei,
+        chain_name: str = "gnosis",
+    ) -> bool:
+        """Approve ERC20 token allowance."""
+        owner_account = self.account_service.resolve_account(owner_address_or_tag)
+        spender_account = self.account_service.resolve_account(spender_address_or_tag)
+        spender_address = spender_account.address if spender_account else spender_address_or_tag
+
+        if not owner_account:
+            logger.error(f"Owner account '{owner_address_or_tag}' not found in wallet.")
+            return False
+
+        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 False
+
+        erc20 = ERC20Contract(token_address, chain_name)
+
+        allowance_wei = self.get_erc20_allowance(
+            owner_address_or_tag,
+            spender_address,
+            token_address_or_name,
+            chain_name,
+        )
+        if allowance_wei is not None and allowance_wei >= amount_wei:
+            logger.info("Current allowance is sufficient. No need to approve.")
+            return True
+
+        transaction = erc20.prepare_approve_tx(
+            from_address=owner_account.address,
+            spender=spender_address,
+            amount_wei=amount_wei,
+        )
+        if not transaction:
+            return False
+
+        is_safe = getattr(owner_account, "threshold", None) is not None
+        amount_eth = float(chain_interface.web3.from_wei(amount_wei, "ether"))
+
+        logger.info(
+            f"Approving {spender_address} to spend {amount_eth:.4f} {token_address_or_name} from {owner_address_or_tag}"
+        )
+
+        if is_safe:
+            tx_limit = self.safe_service.execute_safe_transaction(
+                safe_address_or_tag=owner_address_or_tag,
+                to=erc20.address,
+                value=0,
+                chain_name=chain_name,
+                data=transaction["data"],
+            )
+            return bool(tx_limit)
+        else:
+            success, _ = self.transaction_service.sign_and_send(
+                transaction, owner_address_or_tag, chain_name
+            )
+            return success
+
+    def transfer_from_erc20(
+        self: "TransferService",
+        from_address_or_tag: str,
+        sender_address_or_tag: str,
+        recipient_address_or_tag: str,
+        token_address_or_name: str,
+        amount_wei: Wei,
+        chain_name: str = "gnosis",
+    ):
+        """TransferFrom ERC20 tokens."""
+        from_account = self.account_service.resolve_account(from_address_or_tag)
+        sender_account = self.account_service.resolve_account(sender_address_or_tag)
+        recipient_account = self.account_service.resolve_account(recipient_address_or_tag)
+        recipient_address = (
+            recipient_account.address if recipient_account else recipient_address_or_tag
+        )
+
+        if not sender_account:
+            logger.error(f"Sender account '{sender_address_or_tag}' not found in wallet.")
+            return None
+
+        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
+
+        erc20 = ERC20Contract(token_address, chain_name)
+        transaction = erc20.prepare_transfer_from_tx(
+            from_address=from_account.address,
+            sender=sender_account.address,
+            recipient=recipient_address,
+            amount_wei=amount_wei,
+        )
+        if not transaction:
+            return
+
+        is_safe = getattr(from_account, "threshold", None) is not None
+
+        logger.info("Transferring ERC20 tokens via TransferFrom")
+
+        if is_safe:
+            self.safe_service.execute_safe_transaction(
+                safe_address_or_tag=from_address_or_tag,
+                to=erc20.address,
+                value=0,
+                chain_name=chain_name,
+                data=transaction["data"],
+            )
+        else:
+            self.transaction_service.sign_and_send(transaction, from_address_or_tag, chain_name)

iwa/core/services/transfer/multisend.py

@@ -0,0 +1,386 @@
+"""Multisend and drain mixin."""
+
+from typing import TYPE_CHECKING, Optional
+
+from loguru import logger
+from safe_eth.safe import SafeOperationEnum
+
+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 (
+    MULTISEND_ADDRESS,
+    MULTISEND_CALL_ONLY_ADDRESS,
+    MultiSendCallOnlyContract,
+    MultiSendContract,
+)
+from iwa.core.models import Config, StoredSafeAccount
+
+if TYPE_CHECKING:
+    from iwa.core.services.transfer import TransferService
+
+
+class MultiSendMixin:
+    """Mixin for multisend and drain operations."""
+
+    def multi_send(
+        self: "TransferService",
+        from_address_or_tag: str,
+        transactions: list,
+        chain_name: str = "gnosis",
+    ):
+        """Send multiple transactions in a single multisend transaction."""
+        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
+
+        is_safe = isinstance(from_account, StoredSafeAccount)
+        chain_interface = ChainInterfaces().get(chain_name)
+
+        if not is_safe:
+            self._handle_erc20_approvals(from_address_or_tag, transactions, chain_interface)
+
+        valid_transactions = []
+        for tx in transactions:
+            prepared_tx = self._prepare_multisend_transaction(
+                tx, from_account, chain_interface, is_safe
+            )
+            if prepared_tx:
+                valid_transactions.append(prepared_tx)
+
+        if not valid_transactions:
+            logger.error("No valid transactions to send")
+            return
+
+        return self._execute_multisend(
+            from_account, from_address_or_tag, valid_transactions, chain_interface, is_safe
+        )
+
+    def _handle_erc20_approvals(
+        self: "TransferService",
+        from_address_or_tag: str,
+        transactions: list,
+        chain_interface,
+    ):
+        """Check allowances and approve ERC20s if needed (for EOAs)."""
+        from_account = self.account_service.resolve_account(from_address_or_tag)
+
+        if getattr(from_account, "threshold", None) is not None:
+            return
+
+        is_all_native = all(
+            tx.get("token", NATIVE_CURRENCY_ADDRESS) == NATIVE_CURRENCY_ADDRESS
+            for tx in transactions
+        )
+        if is_all_native:
+            return
+
+        erc20_totals = {}
+        for tx in transactions:
+            token_addr_or_tag = tx.get("token", NATIVE_CURRENCY_ADDRESS)
+            if token_addr_or_tag == NATIVE_CURRENCY_ADDRESS:
+                continue
+
+            token_address = self.account_service.get_token_address(
+                token_addr_or_tag, chain_interface.chain
+            )
+            # Support both amount_wei (preferred) and amount (legacy)
+            if "amount_wei" in tx:
+                amount_wei = tx["amount_wei"]
+            elif "amount" in tx:
+                erc20_temp = ERC20Contract(token_address, chain_interface.chain.name)
+                amount_wei = int(tx["amount"] * (10**erc20_temp.decimals))
+            else:
+                continue
+            erc20_totals[token_address] = erc20_totals.get(token_address, 0) + amount_wei
+
+        for token_addr, total_amount in erc20_totals.items():
+            self.approve_erc20(
+                owner_address_or_tag=from_address_or_tag,
+                spender_address_or_tag=MULTISEND_CALL_ONLY_ADDRESS,
+                token_address_or_name=token_addr,
+                amount_wei=total_amount,
+                chain_name=chain_interface.chain.name,
+            )
+
+    def _prepare_multisend_transaction(
+        self: "TransferService",
+        tx: dict,
+        from_account,
+        chain_interface,
+        is_safe: bool,
+    ) -> Optional[dict]:
+        """Prepare a single transaction for multisend."""
+        tx_copy = dict(tx)
+        to = self.account_service.resolve_account(tx_copy["to"])
+        recipient_address = to.address if to else tx_copy["to"]
+        # Ensure recipient address is checksummed for Web3 compatibility
+        recipient_address = chain_interface.web3.to_checksum_address(recipient_address)
+        token_address_or_tag = tx_copy.get("token", NATIVE_CURRENCY_ADDRESS)
+        chain_name = chain_interface.chain.name
+
+        # Prefer amount_wei if provided (no precision loss), else convert from amount
+        if "amount_wei" in tx_copy:
+            amount_wei = tx_copy["amount_wei"]
+        elif "amount" in tx_copy:
+            # Calculate amount_wei respecting the token's decimals
+            if token_address_or_tag == NATIVE_CURRENCY_ADDRESS:
+                amount_wei = chain_interface.web3.to_wei(tx_copy["amount"], "ether")
+            else:
+                token_address = self.account_service.get_token_address(
+                    token_address_or_tag, chain_interface.chain
+                )
+                erc20_temp = ERC20Contract(token_address, chain_name)
+                # Use the token's actual decimals
+                amount_wei = int(tx_copy["amount"] * (10**erc20_temp.decimals))
+        else:
+            logger.error(f"Transaction missing amount or amount_wei: {tx_copy}")
+            return None
+
+        # Clean up transaction dict
+        tx_copy.pop("amount", None)
+        tx_copy.pop("amount_wei", None)
+        tx_copy.pop("token", None)
+
+        if token_address_or_tag == NATIVE_CURRENCY_ADDRESS:
+            tx_copy["to"] = recipient_address
+            tx_copy["value"] = amount_wei
+            tx_copy["data"] = b""
+            tx_copy["operation"] = SafeOperationEnum.CALL
+        else:
+            # Create ERC20 contract instance for the transfer
+            token_address = self.account_service.get_token_address(
+                token_address_or_tag, chain_interface.chain
+            )
+            erc20 = ERC20Contract(token_address, chain_name)
+
+            if is_safe:
+                # Safe uses transfer() because it DelegateCalls the MultiSend (sender identity preserved)
+                transfer_tx = erc20.prepare_transfer_tx(
+                    from_address=from_account.address,
+                    to=recipient_address,
+                    amount_wei=amount_wei,
+                )
+            else:
+                # EOA uses transferFrom() because MultiSendCallOnly matches the calls (sender is MultiSend contract)
+                transfer_tx = erc20.prepare_transfer_from_tx(
+                    from_address=from_account.address,
+                    sender=from_account.address,
+                    recipient=recipient_address,
+                    amount_wei=amount_wei,
+                )
+
+            if not transfer_tx:
+                logger.error(f"Failed to prepare transfer transaction for {token_address_or_tag}")
+                return None
+
+            tx_copy["to"] = erc20.address
+            tx_copy["value"] = 0
+            tx_copy["data"] = transfer_tx["data"]
+            tx_copy["operation"] = SafeOperationEnum.CALL
+
+        return tx_copy
+
+    def _execute_multisend(
+        self: "TransferService",
+        from_account,
+        from_address_or_tag: str,
+        valid_transactions: list,
+        chain_interface,
+        is_safe: bool,
+    ):
+        """Build and execute the multisend transaction."""
+        chain_name = chain_interface.chain.name
+        multi_send_normal_contract = MultiSendContract(
+            address=MULTISEND_ADDRESS, chain_name=chain_name
+        )
+        multi_send_call_only_contract = MultiSendCallOnlyContract(
+            address=MULTISEND_CALL_ONLY_ADDRESS, chain_name=chain_name
+        )
+
+        multi_send_contract = (
+            multi_send_normal_contract if is_safe else multi_send_call_only_contract
+        )
+        transaction = multi_send_contract.prepare_tx(
+            from_address=from_account.address, transactions=valid_transactions
+        )
+        if not transaction:
+            return
+
+        logger.info("Sending multisend transaction")
+
+        if is_safe:
+            return self.safe_service.execute_safe_transaction(
+                safe_address_or_tag=from_address_or_tag,
+                to=multi_send_contract.address,
+                value=transaction["value"],
+                chain_name=chain_name,
+                data=transaction["data"],
+                operation=SafeOperationEnum.DELEGATE_CALL.value,
+            )
+        else:
+            return self.transaction_service.sign_and_send(
+                transaction, from_address_or_tag, chain_name
+            )
+
+    def drain(
+        self: "TransferService",
+        from_address_or_tag: str,
+        to_address_or_tag: str = "master",
+        chain_name: str = "gnosis",
+    ):
+        """Drain entire balance of an account to another account.
+
+        For Safes that are Olas service multisigs, this will first claim any
+        pending staking rewards before draining.
+
+        Uses multi_send to batch all transfers (ERC20 + native) into a single
+        transaction for gas efficiency.
+        """
+        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
+
+        to_account = self.account_service.resolve_account(to_address_or_tag)
+        to_address = to_account.address if to_account else to_address_or_tag
+
+        is_safe = getattr(from_account, "threshold", None) is not None
+        chain_interface = ChainInterfaces().get(chain_name)
+
+        # If this is a Safe, check if it's an Olas service multisig and claim rewards
+        if is_safe:
+            self._claim_olas_rewards_if_service(from_account.address, chain_name)
+
+        transactions = []
+
+        # Collect ERC-20 token transfers
+        for token_name in chain_interface.chain.tokens.keys():
+            balance_wei = self.balance_service.get_erc20_balance_wei(
+                from_address_or_tag, token_name, chain_name
+            )
+            if balance_wei and balance_wei > 0:
+                # Use amount_wei directly for zero precision loss
+                transactions.append(
+                    {
+                        "to": to_address,
+                        "amount_wei": balance_wei,
+                        "token": token_name,
+                    }
+                )
+                logger.info(f"Queued {balance_wei} wei of {token_name} for drain.")
+            else:
+                logger.debug(f"No {token_name} to drain on {from_address_or_tag}.")
+
+        # Calculate drainable native balance
+        native_balance_wei = self.balance_service.get_native_balance_wei(from_account.address)
+        if native_balance_wei and native_balance_wei > 0:
+            if is_safe:
+                # Safe pays gas from the Safe, so we can drain all
+                drainable_balance_wei = native_balance_wei
+            else:
+                # EOA needs to reserve gas for the multi_send transaction
+                # Conservative estimate: base 100k + ~50k per transfer + 20% buffer
+                num_transfers = len(transactions) + 1  # +1 for native
+                estimated_gas = 100_000 + (50_000 * num_transfers)
+                gas_price = chain_interface.web3.eth.gas_price
+                gas_cost_wei = int(gas_price * estimated_gas * 1.2)  # 20% buffer
+                drainable_balance_wei = native_balance_wei - gas_cost_wei
+                logger.debug(
+                    f"EOA drain: balance={native_balance_wei}, gas_reserve={gas_cost_wei}, "
+                    f"drainable={drainable_balance_wei}"
+                )
+
+            if drainable_balance_wei > 0:
+                # Use amount_wei directly for zero precision loss
+                transactions.append(
+                    {
+                        "to": to_address,
+                        "amount_wei": drainable_balance_wei,
+                        # No "token" key = native currency
+                    }
+                )
+                logger.info(f"Queued {drainable_balance_wei} wei native for drain.")
+            else:
+                logger.info(
+                    f"Not enough native balance to cover gas fees for draining from {from_address_or_tag}."
+                )
+
+        if not transactions:
+            logger.info(f"Nothing to drain from {from_address_or_tag}.")
+            return
+
+        logger.info(
+            f"Draining {len(transactions)} assets from {from_address_or_tag} to {to_address_or_tag}..."
+        )
+        return self.multi_send(
+            from_address_or_tag=from_address_or_tag,
+            transactions=transactions,
+            chain_name=chain_name,
+        )
+
+    def _claim_olas_rewards_if_service(self, safe_address: str, chain_name: str) -> bool:
+        """Check if Safe is an Olas service multisig and claim pending rewards.
+
+        This is a best-effort operation - if the Olas plugin is not available or
+        there's an error, it will log a warning and continue without failing.
+
+        Args:
+            safe_address: The Safe address to check.
+            chain_name: The chain name.
+
+        Returns:
+            True if rewards were claimed, False otherwise.
+
+        """
+        try:
+            # Import Olas plugin (optional dependency)
+            from iwa.plugins.olas.models import OlasConfig
+
+            # Check if this Safe is an Olas service multisig
+            config = Config()
+            if "olas" not in config.plugins:
+                return False
+
+            olas_config: OlasConfig = config.plugins["olas"]
+            service = olas_config.get_service_by_multisig(safe_address)
+
+            if not service:
+                logger.debug(f"Safe {safe_address} is not an Olas service multisig.")
+                return False
+
+            if not service.staking_contract_address:
+                logger.debug(f"Olas service {service.key} is not staked.")
+                return False
+
+            logger.info(
+                f"Safe {safe_address} is Olas service {service.key}. "
+                "Checking for pending staking rewards..."
+            )
+
+            # Use ServiceManager to claim rewards
+            # Need to import Wallet dynamically to avoid circular import
+            from iwa.core.wallet import Wallet
+            from iwa.plugins.olas.service_manager import ServiceManager
+
+            wallet = Wallet()
+            service_manager = ServiceManager(wallet=wallet, service_key=service.key)
+            success, claimed_amount = service_manager.claim_rewards()
+
+            if success and claimed_amount > 0:
+                claimed_olas = claimed_amount / 1e18
+                logger.info(f"Claimed {claimed_olas:.4f} OLAS rewards before drain.")
+                return True
+            elif not success:
+                logger.debug("No rewards to claim or claim failed.")
+
+            return False
+
+        except ImportError:
+            logger.debug("Olas plugin not available, skipping reward claiming.")
+            return False
+        except Exception as e:
+            logger.warning(f"Failed to check/claim Olas rewards: {e}")
+            return False