wayfinder-paths 0.1.7__py3-none-any.whl → 0.1.9__py3-none-any.whl

wayfinder_paths/core/clients/SimulationClient.py

@@ -1,192 +0,0 @@
-"""
-Simulation Client
-Handles blockchain transaction simulations via Gorlami/Tenderly
-"""
-
-from __future__ import annotations
-
-import time
-from typing import NotRequired, Required, TypedDict
-
-from loguru import logger
-
-from wayfinder_paths.core.clients.WayfinderClient import WayfinderClient
-
-
-class SimulationResult(TypedDict):
-    """Simulation result structure"""
-
-    success: Required[bool]
-    gas_used: NotRequired[str | None]
-    gas_price: NotRequired[str | None]
-    balances: NotRequired[dict[str, str]]
-    error: NotRequired[str | None]
-
-
-class SimulationClient(WayfinderClient):
-    """Client for blockchain transaction simulations"""
-
-    def __init__(self, api_key: str | None = None):
-        super().__init__(api_key=api_key)
-
-    async def simulate_send(
-        self,
-        from_address: str,
-        to_address: str,
-        token_address: str,
-        amount: str,
-        chain_id: int,
-        initial_balances: dict[str, str],
-    ) -> SimulationResult:
-        """
-        Simulate sending native ETH or ERC20 tokens.
-
-        Args:
-            from_address: Source wallet address
-            to_address: Destination wallet address
-            token_address: Token contract address (use 0x0 for native ETH)
-            amount: Amount to send
-            chain_id: Blockchain chain ID
-            initial_balances: Initial token balances for simulation
-
-        Returns:
-            Simulation result data
-        """
-        logger.info(
-            f"Simulating send: {amount} from {from_address} to {to_address} (chain {chain_id})"
-        )
-        start_time = time.time()
-
-        url = f"{self.api_base_url}public/simulate/send/"
-
-        payload = {
-            "from_address": from_address,
-            "to_address": to_address,
-            "token_address": token_address,
-            "amount": amount,
-            "chain_id": chain_id,
-            "initial_balances": initial_balances,
-        }
-
-        try:
-            response = await self._request("POST", url, json=payload, headers={})
-            response.raise_for_status()
-            data = response.json()
-            elapsed = time.time() - start_time
-            logger.info(f"Simulation request completed successfully in {elapsed:.2f}s")
-            return data.get("data", data)
-        except Exception as e:
-            elapsed = time.time() - start_time
-            logger.error(f"Simulation request failed after {elapsed:.2f}s: {e}")
-            raise
-
-    async def simulate_approve(
-        self,
-        from_address: str,
-        to_address: str,
-        token_address: str,
-        amount: str,
-        chain_id: int,
-        initial_balances: dict[str, str],
-        clear_approval_first: bool = False,
-    ) -> SimulationResult:
-        """
-        Simulate ERC20 token approval.
-
-        Args:
-            from_address: Address approving the tokens
-            to_address: Address being approved to spend tokens
-            token_address: ERC20 token contract address
-            amount: Amount to approve
-            chain_id: Blockchain chain ID
-            initial_balances: Initial token balances for simulation
-            clear_approval_first: Whether to clear existing approval before setting new one
-
-        Returns:
-            Simulation result data
-        """
-        logger.info(
-            f"Simulating approval: {amount} from {from_address} to {to_address} (chain {chain_id})"
-        )
-        start_time = time.time()
-
-        url = f"{self.api_base_url}public/simulate/approve/"
-
-        payload = {
-            "from_address": from_address,
-            "to_address": to_address,
-            "token_address": token_address,
-            "amount": amount,
-            "chain_id": chain_id,
-            "initial_balances": initial_balances,
-            "clear_approval_first": clear_approval_first,
-        }
-
-        try:
-            response = await self._request("POST", url, json=payload, headers={})
-            response.raise_for_status()
-            data = response.json()
-            elapsed = time.time() - start_time
-            logger.info(f"Simulation request completed successfully in {elapsed:.2f}s")
-            return data.get("data", data)
-        except Exception as e:
-            elapsed = time.time() - start_time
-            logger.error(f"Simulation request failed after {elapsed:.2f}s: {e}")
-            raise
-
-    async def simulate_swap(
-        self,
-        from_token_address: str,
-        to_token_address: str,
-        from_chain_id: int,
-        to_chain_id: int,
-        amount: str,
-        from_address: str,
-        slippage: float,
-        initial_balances: dict[str, str],
-    ) -> SimulationResult:
-        """
-        Simulate token swap operation.
-
-        Args:
-            from_token_address: Source token contract address
-            to_token_address: Destination token contract address
-            from_chain_id: Source chain ID
-            to_chain_id: Destination chain ID
-            amount: Amount to swap
-            from_address: Wallet address initiating swap
-            slippage: Maximum slippage tolerance
-            initial_balances: Initial token balances for simulation
-
-        Returns:
-            Simulation result data
-        """
-        logger.info(
-            f"Simulating swap: {from_token_address} -> {to_token_address} (chain {from_chain_id} -> {to_chain_id})"
-        )
-        start_time = time.time()
-
-        url = f"{self.api_base_url}public/simulate/swap/"
-
-        payload = {
-            "from_token_address": from_token_address,
-            "to_token_address": to_token_address,
-            "from_chain_id": from_chain_id,
-            "to_chain_id": to_chain_id,
-            "amount": amount,
-            "from_address": from_address,
-            "slippage": slippage,
-            "initial_balances": initial_balances,
-        }
-
-        try:
-            response = await self._request("POST", url, json=payload, headers={})
-            response.raise_for_status()
-            data = response.json()
-            elapsed = time.time() - start_time
-            logger.info(f"Simulation request completed successfully in {elapsed:.2f}s")
-            return data.get("data", data)
-        except Exception as e:
-            elapsed = time.time() - start_time
-            logger.error(f"Simulation request failed after {elapsed:.2f}s: {e}")
-            raise

wayfinder_paths/core/clients/TransactionClient.py

@@ -1,63 +0,0 @@
-"""
-Transaction Client
-Handles transaction building, gas estimation, and monitoring
-"""
-
-from __future__ import annotations
-
-from typing import NotRequired, Required, TypedDict
-
-from wayfinder_paths.core.clients.AuthClient import AuthClient
-from wayfinder_paths.core.clients.WayfinderClient import WayfinderClient
-from wayfinder_paths.core.settings import settings
-
-
-class TransactionPayload(TypedDict):
-    """Transaction payload structure"""
-
-    from_address: Required[str]
-    to_address: Required[str]
-    token_address: Required[str]
-    amount: Required[str]
-    chain_id: Required[int]
-    data: NotRequired[str | None]
-    value: NotRequired[str | None]
-    gas_limit: NotRequired[str | None]
-    gas_price: NotRequired[str | None]
-
-
-class TransactionClient(WayfinderClient):
-    """Client for transaction operations"""
-
-    def __init__(self, api_key: str | None = None):
-        super().__init__(api_key=api_key)
-        self.api_base_url = f"{self.api_base_url}/transactions"
-        self._auth_client: AuthClient | None = AuthClient(api_key=api_key)
-
-    # ============== Protected (Auth Required) Endpoints ==============
-
-    async def build_send(
-        self,
-        from_address: str,
-        to_address: str,
-        token_address: str,
-        amount: float,
-        chain_id: int,
-    ) -> TransactionPayload:
-        """
-        Build a send transaction payload for EVM tokens/native transfers.
-
-        GET /api/v1/public/transactions/build-send/?from_address=...&to_address=...&token_address=...&amount=...&chain_id=...
-        """
-        url = f"{settings.WAYFINDER_API_URL}/public/transactions/build-send/"
-        params = {
-            "from_address": from_address,
-            "to_address": to_address,
-            "token_address": token_address,
-            "amount": str(amount),
-            "chain_id": str(chain_id),
-        }
-        response = await self._authed_request("GET", url, params=params)
-        response.raise_for_status()
-        data = response.json()
-        return data.get("data", data)