iwa 0.0.10__tar.gz → 0.0.11__tar.gz

{iwa-0.0.10/src/iwa.egg-info → iwa-0.0.11}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: iwa
-Version: 0.0.10
+Version: 0.0.11
 Summary: A secure, modular, and plugin-based framework for crypto agents and ops
 Requires-Python: <4.0,>=3.12
 Description-Content-Type: text/markdown

{iwa-0.0.10 → iwa-0.0.11}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "iwa"
-version = "0.0.10"
+version = "0.0.11"
 description = "A secure, modular, and plugin-based framework for crypto agents and ops"
 readme = "README.md"
 requires-python = ">=3.12,<4.0"
@@ -71,7 +71,7 @@ where = ["src"]
 
 [tool.ruff]
 line-length = 100
-target-version = "0.0.10"
+target-version = "0.0.11"
 fix = true
 
 [tool.ruff.lint]

{iwa-0.0.10 → iwa-0.0.11}/src/iwa/core/chain/interface.py

@@ -365,15 +365,29 @@ class ChainInterface:
         except Exception:
             return address[:6] + "..." + address[-4:]
 
-    def get_token_decimals(self, address: EthereumAddress) -> int:
-        """Get token decimals for an address."""
-        try:
-            from iwa.core.contracts.erc20 import ERC20Contract
+    def get_token_decimals(self, address: EthereumAddress, fallback_to_18: bool = True) -> Optional[int]:
+        """Get token decimals for an address.
 
-            erc20 = ERC20Contract(address, self.chain.name.lower())
-            return erc20.decimals if erc20.decimals is not None else 18
+        Args:
+            address: Token contract address.
+            fallback_to_18: If True, return 18 on error (default).
+                           If False, return None on error (useful for detecting NFTs).
+
+        Returns:
+            Decimals as int, or None if error and fallback_to_18 is False.
+
+        """
+        try:
+            # Call decimals() directly without with_retry to avoid error logging
+            contract = self.web3.eth.contract(
+                address=self.web3.to_checksum_address(address),
+                abi=[{"constant": True, "inputs": [], "name": "decimals", "outputs": [{"type": "uint8"}], "type": "function"}]
+            )
+            return contract.functions.decimals().call()
         except Exception:
-            return 18
+            if fallback_to_18:
+                return 18
+            return None
 
     def get_native_balance_wei(self, address: EthereumAddress):
         """Get the native balance in wei"""

{iwa-0.0.10 → iwa-0.0.11}/src/iwa/core/services/transaction.py

@@ -1,9 +1,10 @@
 """Transaction service module."""
 
 import time
-from typing import Dict, List, Optional, Tuple
+from typing import TYPE_CHECKING, Dict, List, Optional, Tuple
 
 from loguru import logger
+from web3 import Web3
 from web3 import exceptions as web3_exceptions
 
 from iwa.core.chain import ChainInterfaces
@@ -11,6 +12,191 @@ from iwa.core.db import log_transaction
 from iwa.core.keys import KeyStorage
 from iwa.core.services.account import AccountService
 
+if TYPE_CHECKING:
+    from iwa.core.chain import ChainInterface
+
+# ERC20 Transfer event signature: Transfer(address indexed from, address indexed to, uint256 value)
+TRANSFER_EVENT_TOPIC = "0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef"
+
+
+class TransferLogger:
+    """Parse and log transfer events from transaction receipts."""
+
+    def __init__(
+        self,
+        account_service: AccountService,
+        chain_interface: "ChainInterface",
+    ):
+        """Initialize TransferLogger."""
+        self.account_service = account_service
+        self.chain_interface = chain_interface
+
+    def log_transfers(self, receipt: Dict, tx: Dict) -> None:
+        """Log all transfers (ERC20 and native) from a transaction receipt.
+
+        Args:
+            receipt: Transaction receipt containing logs.
+            tx: Original transaction dict.
+
+        """
+        # Log native value transfer if present
+        native_value = tx.get("value", 0)
+        if native_value and int(native_value) > 0:
+            self._log_native_transfer(tx, native_value)
+
+        # Log ERC20 transfers from event logs
+        logs = receipt.get("logs", [])
+        if hasattr(receipt, "logs"):
+            logs = receipt.logs
+
+        for log in logs:
+            self._process_log(log)
+
+    def _log_native_transfer(self, tx: Dict, value_wei: int) -> None:
+        """Log a native currency transfer."""
+        from_addr = tx.get("from", "")
+        to_addr = tx.get("to", "")
+
+        from_label = self._resolve_address_label(from_addr)
+        to_label = self._resolve_address_label(to_addr)
+
+        native_symbol = self.chain_interface.chain.native_currency
+        amount_eth = Web3.from_wei(value_wei, "ether")
+
+        logger.info(f"[TRANSFER] {amount_eth:.6g} {native_symbol}: {from_label} → {to_label}")
+
+    def _process_log(self, log) -> None:
+        """Process a single log entry for Transfer events."""
+        # Get topics - handle both dict and AttributeDict
+        topics = log.get("topics", []) if isinstance(log, dict) else getattr(log, "topics", [])
+
+        if not topics:
+            return
+
+        # Check if this is a Transfer event
+        first_topic = topics[0]
+        if isinstance(first_topic, bytes):
+            first_topic = "0x" + first_topic.hex()
+        elif hasattr(first_topic, "hex"):
+            first_topic = first_topic.hex()
+            if not first_topic.startswith("0x"):
+                first_topic = "0x" + first_topic
+
+        if first_topic.lower() != TRANSFER_EVENT_TOPIC.lower():
+            return
+
+        # Need at least 3 topics for indexed from/to
+        if len(topics) < 3:
+            return
+
+        try:
+            # Extract from/to from indexed topics (last 20 bytes of 32-byte topic)
+            from_topic = topics[1]
+            to_topic = topics[2]
+
+            from_addr = self._topic_to_address(from_topic)
+            to_addr = self._topic_to_address(to_topic)
+
+            # Extract amount from data
+            data = log.get("data", b"") if isinstance(log, dict) else getattr(log, "data", b"")
+            if isinstance(data, str):
+                data = bytes.fromhex(data.replace("0x", ""))
+
+            amount = int.from_bytes(data, "big") if data else 0
+
+            # Get token address
+            token_addr = (
+                log.get("address", "") if isinstance(log, dict) else getattr(log, "address", "")
+            )
+
+            self._log_erc20_transfer(token_addr, from_addr, to_addr, amount)
+
+        except Exception as e:
+            logger.debug(f"Failed to parse Transfer event: {e}")
+
+    def _topic_to_address(self, topic) -> str:
+        """Convert a 32-byte topic to a 20-byte address."""
+        if isinstance(topic, bytes):
+            # Last 20 bytes
+            addr_bytes = topic[-20:]
+            return Web3.to_checksum_address("0x" + addr_bytes.hex())
+        elif hasattr(topic, "hex"):
+            hex_str = topic.hex()
+            if not hex_str.startswith("0x"):
+                hex_str = "0x" + hex_str
+            # Last 40 chars (20 bytes)
+            return Web3.to_checksum_address("0x" + hex_str[-40:])
+        elif isinstance(topic, str):
+            if topic.startswith("0x"):
+                topic = topic[2:]
+            return Web3.to_checksum_address("0x" + topic[-40:])
+        return ""
+
+    def _log_erc20_transfer(
+        self, token_addr: str, from_addr: str, to_addr: str, amount_wei: int
+    ) -> None:
+        """Log an ERC20 transfer (or NFT transfer if detected)."""
+        from_label = self._resolve_address_label(from_addr)
+        to_label = self._resolve_address_label(to_addr)
+        token_label = self._resolve_token_label(token_addr)
+
+        # Try to get decimals - if None, it's an NFT (ERC721)
+        decimals = self.chain_interface.get_token_decimals(token_addr, fallback_to_18=False)
+
+        if decimals is not None:
+            amount = amount_wei / (10**decimals)
+            logger.info(f"[TRANSFER] {amount:.6g} {token_label}: {from_label} → {to_label}")
+        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}")
+            else:
+                logger.debug(f"[NFT TRANSFER] {token_label}: {from_label} → {to_label}")
+
+    def _resolve_address_label(self, address: str) -> str:
+        """Resolve an address to a human-readable label.
+
+        Priority:
+        1. Known wallet tag (from wallets.json)
+        2. Known token name (it's a token contract)
+        3. Abbreviated address
+
+        """
+        if not address:
+            return "unknown"
+
+        # 1. Check known wallets
+        tag = self.account_service.get_tag_by_address(address)
+        if tag:
+            return tag
+
+        # 2. Check if it's a known token contract
+        token_name = self.chain_interface.chain.get_token_name(address)
+        if token_name:
+            return f"{token_name}_contract"
+
+        # 3. Fallback to abbreviated address
+        return f"{address[:6]}...{address[-4:]}"
+
+    def _resolve_token_label(self, token_addr: str) -> str:
+        """Resolve a token address to its symbol.
+
+        Priority:
+        1. Known token from chain config
+        2. Abbreviated address
+
+        """
+        if not token_addr:
+            return "UNKNOWN"
+
+        # Check known tokens
+        token_name = self.chain_interface.chain.get_token_name(token_addr)
+        if token_name:
+            return token_name
+
+        # Fallback to abbreviated address
+        return f"{token_addr[:6]}...{token_addr[-4:]}"
+
 
 class TransactionService:
     """Manages transaction lifecycle: signing, sending, retrying."""
@@ -54,7 +240,7 @@ class TransactionService:
                     logger.info(f"Transaction sent successfully. Tx Hash: {txn_hash.hex()}")
 
                     self._log_successful_transaction(
-                        receipt, tx, signer_account, chain_name, txn_hash, tags
+                        receipt, tx, signer_account, chain_name, txn_hash, tags, chain_interface
                     )
                     return True, receipt
 
@@ -115,7 +301,9 @@ class TransactionService:
         logger.exception(f"Unexpected error sending transaction: {e}")
         return False
 
-    def _log_successful_transaction(self, receipt, tx, signer_account, chain_name, txn_hash, tags):
+    def _log_successful_transaction(
+        self, receipt, tx, signer_account, chain_name, txn_hash, tags, chain_interface
+    ):
         try:
             gas_cost_wei, gas_value_eur = self._calculate_gas_cost(receipt, tx, chain_name)
             final_tags = self._determine_tags(tx, tags)
@@ -132,6 +320,11 @@ class TransactionService:
                 gas_value_eur=gas_value_eur,
                 tags=final_tags if final_tags else None,
             )
+
+            # Log transfer events (ERC20 and native value)
+            transfer_logger = TransferLogger(self.account_service, chain_interface)
+            transfer_logger.log_transfers(receipt, tx)
+
         except Exception as log_err:
             logger.warning(f"Failed to log transaction: {log_err}")
 

{iwa-0.0.10 → iwa-0.0.11}/src/iwa/core/wallet.py

@@ -92,7 +92,8 @@ class Wallet:
                 return addr, t_name, 0.0
 
         # Use ThreadPoolExecutor for parallel balance fetching
-        with ThreadPoolExecutor(max_workers=20) as executor:
+        # Limited to 4 workers to avoid overwhelming RPC endpoints
+        with ThreadPoolExecutor(max_workers=4) as executor:
             tasks = []
             for addr in accounts_data.keys():
                 for t_name in token_names: