wayfinder-paths 0.1.14__py3-none-any.whl → 0.1.16__py3-none-any.whl

wayfinder_paths/adapters/balance_adapter/README.md

@@ -7,43 +7,42 @@ Adapter that exposes wallet, token, and pool balances backed by `WalletClient`/`
 
 ## Capabilities
 
-The adapter provides both wallet read and wallet transfer capabilities. Transfers are executed by leveraging the shared `DefaultWeb3Service.token_transactions` helper, but ledger recording + wallet selection now live inside the adapter.
+The adapter provides both wallet read and wallet transfer capabilities. Ledger recording + wallet selection now live inside the adapter.
 
 ## Construction
 
 ```python
-from wayfinder_paths.core.services.web3_service import DefaultWeb3Service
 from wayfinder_paths.adapters.balance_adapter.adapter import BalanceAdapter
 
-web3_service = DefaultWeb3Service(config)
-balance = BalanceAdapter(config, web3_service=web3_service)
 ```
 
-`web3_service` is required so the adapter can share the same wallet provider (and `TokenTxn` helper) as the rest of the strategy.
-
 ## API surface
 
-### `get_balance(*, query: str | dict, wallet_address: str, chain_id: int | None = None)`
-Returns the raw balance (as an integer) for a specific token or pool on a wallet.
+### `get_balance(token_id: str, wallet_address: str)`
 
-`query`: token_id/address string or a dict with a `"token_id"` key. When `query` is a token identifier (e.g. `"usd-coin-base"`), `chain_id` is auto-resolved from token info; when it is a pool address, `chain_id` must be provided.
+Returns the raw balance (as an integer) for a specific token on a wallet.
 
 ```python
-# Token balance (chain_id auto-resolved)
 success, balance = await balance.get_balance(
-    query="usd-coin-base",
+    token_id="usd-coin-base",
     wallet_address=config["main_wallet"]["address"],
 )
+```
+
+### `get_pool_balance(pool_address: str, chain_id: int, user_address: str)`
 
-# Pool balance (chain_id required)
-success, pool_balance = await balance.get_balance(
-    query="0xPool...",
-    wallet_address=config["strategy_wallet"]["address"],
+Fetches the amount supplied to a specific pool, using the `/wallets/pool-balance` endpoint.
+
+```python
+success, amount = await balance.get_pool_balance(
+    pool_address="0xPool",
     chain_id=8453,
+    user_address=config["strategy_wallet"]["address"],
 )
 ```
 
 ### `move_from_main_wallet_to_strategy_wallet(token_id: str, amount: float, strategy_name="unknown", skip_ledger=False)`
+
 Sends the specified token from the configured `main_wallet` to the strategy wallet, records the ledger deposit (unless `skip_ledger=True`), and returns the `(success, tx_result)` tuple from the underlying send helper.
 
 ```python
@@ -55,6 +54,7 @@ success, tx = await balance.move_from_main_wallet_to_strategy_wallet(
 ```
 
 ### `move_from_strategy_wallet_to_main_wallet(token_id: str, amount: float, strategy_name="unknown", skip_ledger=False)`
+
 Mirrors the previous method but withdraws from the strategy wallet back to the main wallet while recording a ledger withdrawal entry.
 
 ```python
@@ -73,16 +73,15 @@ All methods return `(success: bool, payload: Any)` tuples. On failure the payloa
 class MyStrategy(Strategy):
     def __init__(self, config):
         super().__init__()
-        web3_service = DefaultWeb3Service(config)
-        balance_adapter = BalanceAdapter(config, web3_service=web3_service)
+        balance_adapter = BalanceAdapter(config)
         self.register_adapters([balance_adapter])
         self.balance_adapter = balance_adapter
 
     async def _status(self):
-        success, pool_balance = await self.balance_adapter.get_balance(
-            query=self.current_pool["address"],
-            wallet_address=self.config["strategy_wallet"]["address"],
+        success, pool_balance = await self.balance_adapter.get_pool_balance(
+            pool_address=self.current_pool["address"],
             chain_id=self.current_pool["chain"]["id"],
+            user_address=self.config["strategy_wallet"]["address"],
         )
         return {"portfolio_value": float(pool_balance or 0), ...}
 ```

wayfinder_paths/adapters/balance_adapter/adapter.py

@@ -5,9 +5,9 @@ from wayfinder_paths.adapters.token_adapter.adapter import TokenAdapter
 from wayfinder_paths.core.adapters.BaseAdapter import BaseAdapter
 from wayfinder_paths.core.clients.TokenClient import TokenClient
 from wayfinder_paths.core.clients.WalletClient import WalletClient
-from wayfinder_paths.core.constants.base import DEFAULT_TRANSACTION_TIMEOUT
-from wayfinder_paths.core.services.base import Web3Service
+from wayfinder_paths.core.utils.erc20_service import build_send_transaction
 from wayfinder_paths.core.utils.evm_helpers import resolve_chain_id
+from wayfinder_paths.core.utils.transaction import send_transaction
 
 
 class BalanceAdapter(BaseAdapter):
@@ -16,17 +16,19 @@ class BalanceAdapter(BaseAdapter):
     def __init__(
         self,
         config: dict[str, Any],
-        web3_service: Web3Service,
+        simulation: bool = False,
+        main_wallet_signing_callback=None,
+        strategy_wallet_signing_callback=None,
     ):
         super().__init__("balance", config)
+        self.simulation = simulation
+        self.main_wallet_signing_callback = main_wallet_signing_callback
+        self.strategy_wallet_signing_callback = strategy_wallet_signing_callback
         self.wallet_client = WalletClient()
         self.token_client = TokenClient()
         self.token_adapter = TokenAdapter()
         self.ledger_adapter = LedgerAdapter()
 
-        self.wallet_provider = web3_service.evm_transactions
-        self.token_transactions = web3_service.token_transactions
-
     def _parse_balance(self, raw: Any) -> int:
         """Parse balance value to integer, handling various formats."""
         if raw is None:
@@ -42,15 +44,23 @@ class BalanceAdapter(BaseAdapter):
     async def get_balance(
         self,
         *,
-        query: str | dict[str, Any],
+        query: str | dict[str, Any] | None = None,
+        token_id: str | None = None,
         wallet_address: str,
         chain_id: int | None = None,
     ) -> tuple[bool, str | int]:
         """Get token or pool balance for a wallet.
 
         query: token_id/address string or a dict with a "token_id" key.
+        token_id: alternative to query for convenience.
         """
-        resolved = query if isinstance(query, str) else (query or {}).get("token_id")
+        # Support both query= and token_id= for caller convenience
+        effective_query = query if query is not None else token_id
+        resolved = (
+            effective_query
+            if isinstance(effective_query, str)
+            else (effective_query or {}).get("token_id")
+        )
         if not resolved:
             return (False, "missing query")
         try:
@@ -116,6 +126,50 @@ class BalanceAdapter(BaseAdapter):
             skip_ledger=skip_ledger,
         )
 
+    async def send_to_address(
+        self,
+        token_id: str,
+        amount: int,
+        from_wallet: dict[str, Any] | None,
+        to_address: str,
+        signing_callback=None,
+        skip_ledger: bool = True,
+    ) -> tuple[bool, Any]:
+        """Send tokens from a wallet to an arbitrary address (e.g., bridge contract)."""
+        from_address = self._wallet_address(from_wallet)
+        if not from_address:
+            return False, "from_wallet missing or invalid"
+
+        if not to_address:
+            return False, "to_address is required"
+
+        token_info = await self.token_client.get_token_details(token_id)
+        if not token_info:
+            return False, f"Token not found: {token_id}"
+
+        chain_id = resolve_chain_id(token_info, self.logger)
+        if chain_id is None:
+            return False, f"Token {token_id} is missing chain_id"
+
+        token_address = token_info.get("address")
+
+        tx = await build_send_transaction(
+            from_address=from_address,
+            to_address=to_address,
+            token_address=token_address,
+            chain_id=chain_id,
+            amount=int(amount),
+        )
+
+        if self.simulation:
+            return True, {"simulation": tx}
+
+        if not signing_callback:
+            return False, "signing_callback is required"
+
+        tx_hash = await send_transaction(tx, signing_callback)
+        return True, tx_hash
+
     async def _move_between_wallets(
         self,
         *,
@@ -128,9 +182,6 @@ class BalanceAdapter(BaseAdapter):
         strategy_name: str,
         skip_ledger: bool,
     ) -> tuple[bool, Any]:
-        if self.token_transactions is None:
-            return False, "Token transaction service not configured"
-
         from_address = self._wallet_address(from_wallet)
         to_address = self._wallet_address(to_wallet)
         if not from_address or not to_address:
@@ -140,20 +191,21 @@ class BalanceAdapter(BaseAdapter):
         if not token_info:
             return False, f"Token not found: {token_id}"
 
-        build_success, tx_data = await self.token_transactions.build_send(
-            token_id=token_id,
-            amount=amount,
+        chain_id = resolve_chain_id(token_info, self.logger)
+        if chain_id is None:
+            return False, f"Token {token_id} is missing chain_id"
+
+        decimals = token_info.get("decimals", 18)
+        raw_amount = int(amount * (10**decimals))
+
+        tx = await build_send_transaction(
             from_address=from_address,
             to_address=to_address,
-            token_info=token_info,
-        )
-        if not build_success:
-            return False, tx_data
-
-        tx = tx_data
-        broadcast_result = await self.wallet_provider.broadcast_transaction(
-            tx, wait_for_receipt=True, timeout=DEFAULT_TRANSACTION_TIMEOUT
+            token_address=token_info.get("address"),
+            chain_id=chain_id,
+            amount=raw_amount,
         )
+        broadcast_result = await self._send_tx(tx, from_address)
 
         if broadcast_result[0] and not skip_ledger and ledger_method is not None:
             wallet_for_ledger = from_address if ledger_wallet == "from" else to_address
@@ -167,6 +219,23 @@ class BalanceAdapter(BaseAdapter):
 
         return broadcast_result
 
+    async def _send_tx(self, tx: dict[str, Any], from_address: str) -> tuple[bool, Any]:
+        """Send transaction with simulation check, using appropriate signing callback."""
+        if self.simulation:
+            return True, {"simulation": tx}
+
+        # Choose callback based on which wallet is sending
+        main_wallet = self.config.get("main_wallet") or {}
+        main_addr = main_wallet.get("address", "").lower()
+
+        if from_address.lower() == main_addr:
+            callback = self.main_wallet_signing_callback
+        else:
+            callback = self.strategy_wallet_signing_callback
+
+        txn_hash = await send_transaction(tx, callback)
+        return True, txn_hash
+
     async def _record_ledger_entry(
         self,
         *,

wayfinder_paths/adapters/balance_adapter/test_adapter.py

@@ -21,13 +21,7 @@ class TestBalanceAdapter:
         return mock_client
 
     @pytest.fixture
-    def mock_web3_service(self):
-        """Mock TokenClient for testing"""
-        mock_client = AsyncMock()
-        return mock_client
-
-    @pytest.fixture
-    def adapter(self, mock_wallet_client, mock_token_client, mock_web3_service):
+    def adapter(self, mock_wallet_client, mock_token_client):
         """Create a BalanceAdapter instance with mocked clients for testing"""
         with (
             patch(
@@ -39,7 +33,7 @@ class TestBalanceAdapter:
                 return_value=mock_token_client,
             ),
         ):
-            return BalanceAdapter(config={}, web3_service=mock_web3_service)
+            return BalanceAdapter(config={})
 
     @pytest.mark.asyncio
     async def test_health_check(self, adapter):
@@ -79,7 +73,7 @@ class TestBalanceAdapter:
             wallet_address="0xWallet",
         )
 
-        assert success is True
+        assert success
         assert balance == 1000000
         mock_token_client.get_token_details.assert_called_once_with("usd-coin-base")
         mock_wallet_client.get_token_balance_for_address.assert_called_once_with(
@@ -108,7 +102,7 @@ class TestBalanceAdapter:
             query={"token_id": "wsteth-base"},
             wallet_address="0x123",
         )
-        assert success is True
+        assert success
         assert balance == 3000000
         mock_token_client.get_token_details.assert_called_once_with("wsteth-base")
         mock_wallet_client.get_token_balance_for_address.assert_called_once_with(
@@ -140,7 +134,7 @@ class TestBalanceAdapter:
             chain_id=8453,
         )
 
-        assert success is True
+        assert success
         assert balance == 5000000
         mock_wallet_client.get_token_balance_for_address.assert_called_once_with(
             wallet_address="0xWallet",

wayfinder_paths/adapters/brap_adapter/README.md

@@ -13,9 +13,8 @@ A Wayfinder adapter that provides high-level operations for cross-chain swaps an
 
 ## Configuration
 
-The adapter uses the BRAPClient which automatically handles authentication and API configuration through the Wayfinder settings. Pass a `Web3Service` instance so it can broadcast transactions and reuse the shared `LocalTokenTxnService` for approvals.
-
 The BRAPClient will automatically:
+
 - Use the WAYFINDER_API_URL from settings
 - Handle authentication via config.json
 - Manage token refresh and retry logic
@@ -25,11 +24,9 @@ The BRAPClient will automatically:
 ### Initialize the Adapter
 
 ```python
-from wayfinder_paths.core.services.web3_service import DefaultWeb3Service
 from wayfinder_paths.adapters.brap_adapter.adapter import BRAPAdapter
 
-web3_service = DefaultWeb3Service(config)
-adapter = BRAPAdapter(web3_service=web3_service)
+adapter = BRAPAdapter()
 ```
 
 ### Get Swap Quote
@@ -46,9 +43,10 @@ success, data = await adapter.get_swap_quote(
     slippage=0.01  # 1% slippage
 )
 if success:
-    best_quote = data.get("best_quote", {})
+    quotes = data.get("quotes", {})
+    best_quote = quotes.get("best_quote", {})
     print(f"Output amount: {best_quote.get('output_amount')}")
-    print(f"Fee estimate: {best_quote.get('fee_estimate', {}).get('fee_total_usd')}")
+    print(f"Total fee: {best_quote.get('total_fee')}")
 else:
     print(f"Error: {data}")
 ```
@@ -67,7 +65,8 @@ success, data = await adapter.get_best_quote(
 )
 if success:
     print(f"Best output: {data.get('output_amount')}")
-    print(f"Fee estimate (USD): {data.get('fee_estimate', {}).get('fee_total_usd')}")
+    print(f"Gas fee: {data.get('gas_fee')}")
+    print(f"Bridge fee: {data.get('bridge_fee')}")
 else:
     print(f"Error: {data}")
 ```
@@ -86,8 +85,10 @@ success, data = await adapter.calculate_swap_fees(
 if success:
     print(f"Input amount: {data.get('input_amount')}")
     print(f"Output amount: {data.get('output_amount')}")
-    print(f"Gas estimate: {data.get('gas_fee')}")
-    print(f"Total fee (USD): {data.get('total_fee')}")
+    print(f"Gas fee: {data.get('gas_fee')}")
+    print(f"Bridge fee: {data.get('bridge_fee')}")
+    print(f"Protocol fee: {data.get('protocol_fee')}")
+    print(f"Total fee: {data.get('total_fee')}")
     print(f"Price impact: {data.get('price_impact')}")
 else:
     print(f"Error: {data}")
@@ -106,9 +107,9 @@ success, data = await adapter.compare_routes(
 if success:
     print(f"Total routes available: {data.get('total_routes')}")
     print(f"Best route output: {data.get('best_route', {}).get('output_amount')}")
-    
+
     for i, route in enumerate(data.get('all_routes', [])):
-        print(f\"Route {i+1}: Output {route.get('output_amount')}, Fee USD {route.get('fee_estimate', {}).get('fee_total_usd')}\")
+        print(f"Route {i+1}: Output {route.get('output_amount')}, Fee {route.get('total_fee')}")
 else:
     print(f"Error: {data}")
 ```
@@ -166,7 +167,7 @@ success, data = await adapter.get_bridge_quote(
     slippage=0.01
 )
 if success:
-    print(f"Bridge quote received: {data.get('best_quote', {}).get('output_amount')}")
+    print(f"Bridge quote received: {data.get('quotes', {}).get('best_quote', {}).get('output_amount')}")
 else:
     print(f"Error: {data}")
 ```
@@ -190,9 +191,10 @@ if success:
     highest_output = analysis.get("highest_output")
     lowest_fees = analysis.get("lowest_fees")
     fastest = analysis.get("fastest")
-    
+
     print(f"Highest output route: {highest_output.get('output_amount')}")
-    print(f\"Lowest fees route (USD): {lowest_fees.get('fee_estimate', {}).get('fee_total_usd')}\")
+    print(f"Lowest fees route: {lowest_fees.get('total_fee')}")
+    print(f"Fastest route: {fastest.get('estimated_time')} seconds")
 ```
 
 ### Fee Analysis
@@ -210,23 +212,24 @@ success, data = await adapter.calculate_swap_fees(
 if success:
     input_amount = int(data.get("input_amount", 0))
     output_amount = int(data.get("output_amount", 0))
-    total_fee_usd = float(data.get("total_fee", 0))
-    
+    total_fee = int(data.get("total_fee", 0))
+
     # Calculate effective rate
     effective_rate = (input_amount - output_amount) / input_amount
     print(f"Effective rate: {effective_rate:.4f} ({effective_rate * 100:.2f}%)")
-    print(f"Total fees: ${total_fee_usd:.4f}")
+    print(f"Total fees: {total_fee / 1e18:.6f} tokens")
 ```
 
 ## API Endpoints
 
 The adapter uses the following Wayfinder API endpoints:
 
-- `GET /api/v1/blockchain/braps/quote/` - Get swap/bridge quotes
+- `POST /api/v1/public/quotes/` - Get swap/bridge quotes
 
 ## Error Handling
 
 All methods return a tuple of `(success: bool, data: Any)` where:
+
 - `success` is `True` if the operation succeeded
 - `data` contains the response data on success or error message on failure
 

wayfinder_paths/adapters/brap_adapter/adapter.py

@@ -15,8 +15,11 @@ from wayfinder_paths.core.clients.BRAPClient import (
 from wayfinder_paths.core.clients.LedgerClient import TransactionRecord
 from wayfinder_paths.core.clients.TokenClient import TokenClient
 from wayfinder_paths.core.constants import DEFAULT_SLIPPAGE, ZERO_ADDRESS
-from wayfinder_paths.core.constants.base import DEFAULT_TRANSACTION_TIMEOUT
-from wayfinder_paths.core.services.base import Web3Service
+from wayfinder_paths.core.utils.erc20_service import (
+    build_approve_transaction,
+    get_token_allowance,
+)
+from wayfinder_paths.core.utils.transaction import send_transaction
 
 _NEEDS_CLEAR_APPROVAL = {
     (1, "0xdac17f958d2ee523a2206206994597c13d831ec7"),
@@ -41,17 +44,16 @@ class BRAPAdapter(BaseAdapter):
     def __init__(
         self,
         config: dict[str, Any] | None = None,
-        *,
-        web3_service: Web3Service,
+        simulation: bool = False,
+        strategy_wallet_signing_callback=None,
     ):
         super().__init__("brap_adapter", config)
+        self.simulation = simulation
+        self.strategy_wallet_signing_callback = strategy_wallet_signing_callback
         self.brap_client = BRAPClient()
         self.token_client = TokenClient()
         self.token_adapter = TokenAdapter()
         self.ledger_adapter = LedgerAdapter()
-        self.web3_service = web3_service
-        self.wallet_provider = web3_service.evm_transactions
-        self.token_transactions = web3_service.token_transactions
 
     async def get_swap_quote(
         self,
@@ -438,11 +440,37 @@ class BRAPAdapter(BaseAdapter):
         if not transaction or not transaction.get("data"):
             return (False, "Quote missing calldata")
         transaction["chainId"] = chain_id
+        if "value" in transaction:
+            transaction["value"] = int(transaction["value"])
         # Always set the sender to the strategy wallet for broadcast.
         # (Calldata may include either "from" or "from_address" depending on provider.)
         transaction["from"] = to_checksum_address(from_address)
 
-        spender = transaction.get("to")
+        def _as_address(value: Any) -> str | None:
+            if not isinstance(value, str):
+                return None
+            v = value.strip()
+            if (
+                v.startswith("0x")
+                and len(v) == 42
+                and v.lower() != ZERO_ADDRESS.lower()
+            ):
+                return v
+            return None
+
+        spender = (
+            _as_address(transaction.get("allowanceTarget"))
+            or _as_address(transaction.get("allowance_target"))
+            or _as_address(transaction.get("approvalAddress"))
+            or _as_address(transaction.get("approval_address"))
+            or _as_address(transaction.get("spender"))
+            or _as_address(quote.get("allowanceTarget"))
+            or _as_address(quote.get("allowance_target"))
+            or _as_address(quote.get("approvalAddress"))
+            or _as_address(quote.get("approval_address"))
+            or _as_address(quote.get("spender"))
+            or _as_address(transaction.get("to"))
+        )
         approve_amount = (
             quote.get("input_amount")
             or quote.get("inputAmount")
@@ -466,16 +494,40 @@ class BRAPAdapter(BaseAdapter):
             if not approve_success:
                 return (False, approve_response)
 
-        broadcast_success, broadcast_response = await self._broadcast_transaction(
-            transaction
-        )
+        broadcast_success, broadcast_response = await self._send_tx(transaction)
         self.logger.info(
             f"Swap broadcast result: success={broadcast_success}, "
             f"response={broadcast_response}"
         )
+        # Log only key fields to avoid spamming raw HexBytes logs
+        if isinstance(broadcast_response, dict):
+            tx_hash_log = broadcast_response.get("tx_hash", "unknown")
+            block_log = broadcast_response.get("block_number", "unknown")
+            status_log = (
+                broadcast_response.get("receipt", {}).get("status", "unknown")
+                if isinstance(broadcast_response.get("receipt"), dict)
+                else "unknown"
+            )
+            self.logger.info(
+                f"Swap broadcast: success={broadcast_success}, tx={tx_hash_log}, block={block_log}, status={status_log}"
+            )
+        else:
+            self.logger.info(f"Swap broadcast: success={broadcast_success}")
         if not broadcast_success:
             return (False, broadcast_response)
 
+        tx_hash = None
+        block_number = None
+        confirmations = None
+        confirmed_block_number = None
+        if isinstance(broadcast_response, dict):
+            tx_hash = broadcast_response.get("tx_hash") or broadcast_response.get(
+                "transaction_hash"
+            )
+            block_number = broadcast_response.get("block_number")
+            confirmations = broadcast_response.get("confirmations")
+            confirmed_block_number = broadcast_response.get("confirmed_block_number")
+
         # Record the swap operation in ledger - but don't let ledger errors fail the swap
         # since the on-chain transaction already succeeded
         try:
@@ -491,15 +543,20 @@ class BRAPAdapter(BaseAdapter):
             self.logger.warning(
                 f"Ledger recording failed (swap succeeded on-chain): {e}"
             )
-            # Return the quote with output amount so caller can proceed
-            ledger_record = {
-                "to_amount": quote.get("output_amount"),
-                "from_amount": quote.get("input_amount"),
-                "tx_hash": broadcast_response.get("tx_hash")
-                if isinstance(broadcast_response, dict)
-                else None,
-            }
-        return (True, ledger_record)
+            ledger_record = {}
+
+        result_payload: dict[str, Any] = {
+            "from_amount": quote.get("input_amount"),
+            "to_amount": quote.get("output_amount"),
+            "tx_hash": tx_hash,
+            "block_number": block_number,
+            "confirmations": confirmations,
+            "confirmed_block_number": confirmed_block_number,
+        }
+        if isinstance(ledger_record, dict):
+            result_payload.update(ledger_record)
+
+        return (True, result_payload)
 
     async def get_bridge_quote(
         self,
@@ -678,46 +735,39 @@ class BRAPAdapter(BaseAdapter):
         spender_checksum = to_checksum_address(spender_address)
 
         if (chain_id, token_checksum.lower()) in _NEEDS_CLEAR_APPROVAL:
-            allowance = await self.token_transactions.read_erc20_allowance(
-                {"id": chain_id},
+            allowance = await get_token_allowance(
                 token_checksum,
+                chain_id,
                 owner_checksum,
                 spender_checksum,
             )
-            if allowance.get("allowance", 0) > 0:
-                clear_success, clear_tx = self.token_transactions.build_erc20_approve(
+            if allowance > 0:
+                clear_tx = await build_approve_transaction(
+                    from_address=owner_checksum,
                     chain_id=chain_id,
                     token_address=token_checksum,
-                    from_address=owner_checksum,
-                    spender=spender_checksum,
+                    spender_address=spender_checksum,
                     amount=0,
                 )
-                if not clear_success:
-                    return False, clear_tx
-                clear_result = await self._broadcast_transaction(clear_tx)
+                clear_result = await self._send_tx(clear_tx)
                 if not clear_result[0]:
                     return clear_result
 
-        build_success, approve_tx = self.token_transactions.build_erc20_approve(
+        approve_tx = await build_approve_transaction(
+            from_address=owner_checksum,
             chain_id=chain_id,
             token_address=token_checksum,
-            from_address=owner_checksum,
-            spender=spender_checksum,
+            spender_address=spender_checksum,
             amount=int(amount),
         )
-        if not build_success:
-            return False, approve_tx
-        return await self._broadcast_transaction(approve_tx, confirmations=2)
-
-    async def _broadcast_transaction(
-        self, transaction: dict[str, Any], confirmations: int = 0
-    ) -> tuple[bool, Any]:
-        return await self.wallet_provider.broadcast_transaction(
-            transaction,
-            wait_for_receipt=True,
-            timeout=DEFAULT_TRANSACTION_TIMEOUT,
-            confirmations=confirmations,
-        )
+        return await self._send_tx(approve_tx)
+
+    async def _send_tx(self, tx: dict[str, Any]) -> tuple[bool, Any]:
+        """Send transaction with simulation check."""
+        if self.simulation:
+            return True, {"simulation": tx}
+        txn_hash = await send_transaction(tx, self.strategy_wallet_signing_callback)
+        return True, txn_hash
 
     async def _record_swap_operation(
         self,