Call process_exit_queue after redeem

Signed-off-by: cyc60 <avsysoev60@gmail.com>

Author: cyc60

src/commands/internal/process_redeemer.py

@@ -22,7 +22,11 @@
     multicall_contract,
     os_token_redeemer_contract,
 )
-from src.common.execution import check_gas_price, transaction_gas_wrapper
+from src.common.execution import (
+    check_gas_price,
+    transaction_gas_wrapper,
+    wait_for_execution_endpoints_synced,
+)
 from src.common.harvest import get_multiple_harvest_params
 from src.common.logging import LOG_LEVELS, setup_logging
 from src.common.utils import log_verbose
@@ -196,17 +200,31 @@ async def process(
     block_number: BlockNumber,
     min_queued_assets: Gwei,
 ) -> None:
+    try:
+        await _redeem_os_token_positions(min_queued_assets=min_queued_assets)
+    finally:
+        # Re-fetch block number after redemption processing
+        # to ensure we read the latest on-chain state.
+        block_number = await execution_client.eth.block_number
+        await _process_exit_queue(block_number)
+
+
+async def _redeem_os_token_positions(
+    min_queued_assets: Gwei,
+) -> None:
+    """Perform the OsToken redemption flow for a single iteration.
+
+    Returns early without raising when there is nothing to redeem; the caller
+    is responsible for processing the exit queue regardless of the outcome.
+    """
     if not await check_gas_price():
         return
 
-    # Step 1: Process exit queue
-    await _process_exit_queue(block_number)
-
     # Re-fetch block number after exit queue processing
     # to ensure we read the latest on-chain state
     block_number = await execution_client.eth.block_number
 
-    # Step 2: Check queued shares
+    # Check queued shares
     queued_shares = await os_token_redeemer_contract.queued_shares(block_number)
     os_token_converter = await create_os_token_converter(block_number)
     queued_assets = os_token_converter.to_assets(queued_shares)
@@ -233,25 +251,25 @@ async def process(
         settings.network_config.VAULT_BALANCE_SYMBOL,
     )
 
-    # Step 3: Fetch ALL positions from IPFS (needed for correct merkle tree)
+    # Fetch ALL positions from IPFS (needed for correct merkle tree)
     all_positions = await fetch_positions_from_ipfs(block_number)
     if not all_positions:
         logger.info('No positions found. Skipping to next interval.')
         return
 
-    # Step 4: Calculate redeemable shares
+    # Calculate redeemable shares
     os_token_positions = await calculate_redeemable_shares(all_positions, prev_nonce, block_number)
     if not os_token_positions:
         logger.info('No redeemable positions found. Skipping to next interval.')
         return
 
-    # Step 5: Bring every involved vault up to date on-chain so subsequent reads
+    # Bring every involved vault up to date on-chain so subsequent reads
     # and redemption transactions run against fresh state — no harvest_params
     # plumbing and no updateVaultState bundled in a multicall.
     vaults = list({position.vault for position in os_token_positions})
     await update_vaults_state(vaults=vaults, block_number=block_number)
 
-    # Step 6: Redeem each position end-to-end in a single loop. Withdrawable assets
+    # Redeem each position end-to-end in a single loop. Withdrawable assets
     # are fetched once per vault and cached; meta vaults short on assets trigger
     # sub-vault redemption inline; one redeemOsTokenPositions tx is submitted per
     # position.
@@ -408,13 +426,16 @@ async def redeem_positions(
             continue
 
         position_to_redeem = replace(position, shares_to_redeem=shares_to_redeem)
-        if not await _submit_redeem_position(
+        receipt_block = await _submit_redeem_position(
             position=position_to_redeem,
             all_positions=all_positions,
             tree_nonce=tree_nonce,
-        ):
+        )
+        if receipt_block is None:
             return
 
+        await wait_for_execution_endpoints_synced(receipt_block)
+
         vault_to_withdrawable[position.vault] = Wei(withdrawable - assets_to_redeem)
         remaining_shares -= shares_to_redeem
 
@@ -513,8 +534,14 @@ async def _submit_redeem_position(
     position: OsTokenPosition,
     all_positions: list[OsTokenPosition],
     tree_nonce: int,
-) -> bool:
-    """Submit one redeemOsTokenPositions transaction for a single position."""
+) -> BlockNumber | None:
+    """Submit one redeemOsTokenPositions transaction for a single position.
+
+    Returns the receipt's block number on a confirmed successful transaction,
+    ``None`` otherwise. The caller uses the returned block as a sync barrier so
+    that subsequent reads (e.g. withdrawable balances for the next position)
+    cannot land on a fallback endpoint that has not yet seen the redemption.
+    """
     multiproof = _build_multi_proof(
         tree_nonce=tree_nonce,
         all_positions=all_positions,
@@ -534,7 +561,7 @@ async def _submit_redeem_position(
             position.vault,
             position.owner,
         )
-        return False
+        return None
 
     tx_hash = Web3.to_hex(tx)
     logger.info(
@@ -553,7 +580,7 @@ async def _submit_redeem_position(
             position.owner,
             tx_hash,
         )
-        return False
+        return None
 
     logger.info(
         'Redeemed %s shares for position (vault %s, owner %s). Tx Hash: %s',
@@ -562,7 +589,7 @@ async def _submit_redeem_position(
         position.owner,
         tx_hash,
     )
-    return True
+    return tx_receipt['blockNumber']
 
 
 def _build_multi_proof(

src/commands/tests/test_internal/test_process_redeemer.py

@@ -286,7 +286,7 @@ async def test_submit_failure_aborts_iteration(self) -> None:
 
         with _mock_redeem_positions(
             withdrawable=Wei(10000),
-            submit_results=[False, True],
+            submit_results=[None, BlockNumber(123)],
         ) as mocks:
             await redeem_positions(
                 all_positions=[pos1, pos2],
@@ -304,40 +304,40 @@ async def test_submit_failure_aborts_iteration(self) -> None:
 
 
 class TestSubmitRedeemPosition:
-    async def test_success_returns_true(self) -> None:
+    async def test_success_returns_receipt_block(self) -> None:
         position = make_position(leaf_shares=1000, shares_to_redeem=500)
         with _mock_submit_redeem_position(tx_status=1) as mocks:
             result = await _submit_redeem_position(
                 position=position,
                 all_positions=[position],
                 tree_nonce=5,
             )
-        assert result is True
+        assert result == BlockNumber(456)
         mocks['transaction_gas_wrapper'].assert_awaited_once()
         mocks['client'].eth.wait_for_transaction_receipt.assert_awaited_once()
 
-    async def test_tx_status_zero_returns_false(self) -> None:
-        """A reverted on-chain tx returns False without raising."""
+    async def test_tx_status_zero_returns_none(self) -> None:
+        """A reverted on-chain tx returns None without raising."""
         position = make_position(leaf_shares=1000, shares_to_redeem=500)
         with _mock_submit_redeem_position(tx_status=0):
             result = await _submit_redeem_position(
                 position=position,
                 all_positions=[position],
                 tree_nonce=5,
             )
-        assert result is False
+        assert result is None
 
     @pytest.mark.parametrize('exc_class', [Web3Exception, RuntimeError, ValueError])
-    async def test_tx_build_failure_returns_false(self, exc_class: type[Exception]) -> None:
-        """Each caught exception during tx build/send returns False."""
+    async def test_tx_build_failure_returns_none(self, exc_class: type[Exception]) -> None:
+        """Each caught exception during tx build/send returns None."""
         position = make_position(leaf_shares=1000, shares_to_redeem=500)
         with _mock_submit_redeem_position(send_exception=exc_class('boom')) as mocks:
             result = await _submit_redeem_position(
                 position=position,
                 all_positions=[position],
                 tree_nonce=5,
             )
-        assert result is False
+        assert result is None
         # Receipt is never awaited when the build step raised
         mocks['client'].eth.wait_for_transaction_receipt.assert_not_awaited()
 
@@ -827,14 +827,14 @@ async def test_successful_redemption(self) -> None:
 def _mock_redeem_positions(
     withdrawable: Wei | AsyncMock | None = None,
     is_meta_vault: bool = False,
-    submit_results: list[bool] | None = None,
+    submit_results: list[BlockNumber | None] | None = None,
 ) -> Iterator[dict[str, MagicMock]]:
     """Mock setup for redeem_positions tests.
 
     ``withdrawable`` may be a constant Wei value (returned on every call) or an
     AsyncMock for fine-grained control (e.g. ``side_effect=[...]`` for sequenced returns).
     ``submit_results`` controls per-call return values of _submit_redeem_position;
-    a False entry models a failed submission that should abort the round.
+    a ``None`` entry models a failed submission that should abort the round.
     """
     if isinstance(withdrawable, AsyncMock):
         get_withdrawable = withdrawable
@@ -846,15 +846,20 @@ def _mock_redeem_positions(
     if submit_results is not None:
         submit_mock = AsyncMock(side_effect=submit_results)
     else:
-        submit_mock = AsyncMock(return_value=True)
+        submit_mock = AsyncMock(return_value=BlockNumber(123))
 
     with (
         patch(f'{MODULE}.get_withdrawable_assets', new=get_withdrawable),
         patch(f'{MODULE}.is_meta_vault', new=AsyncMock(return_value=is_meta_vault)),
         patch(f'{MODULE}._submit_redeem_position', new=submit_mock),
+        patch(
+            f'{MODULE}.wait_for_execution_endpoints_synced',
+            new=AsyncMock(),
+        ) as wait_synced_mock,
     ):
         yield {
             'submit_mock': submit_mock,
+            'wait_synced_mock': wait_synced_mock,
         }
 
 
@@ -875,7 +880,9 @@ def _mock_submit_redeem_position(
     """
     tx = HexBytes(b'\xab' * 32)
     mock_client = AsyncMock()
-    mock_client.eth.wait_for_transaction_receipt = AsyncMock(return_value={'status': tx_status})
+    mock_client.eth.wait_for_transaction_receipt = AsyncMock(
+        return_value={'status': tx_status, 'blockNumber': BlockNumber(456)},
+    )
 
     if send_exception is not None:
         gas_wrapper = AsyncMock(side_effect=send_exception)

src/common/execution.py

@@ -2,6 +2,7 @@
 import logging
 from urllib.parse import urlparse
 
+from eth_typing import BlockNumber
 from hexbytes import HexBytes
 from sw_utils import GasManager, InterruptHandler
 from web3 import Web3
@@ -19,6 +20,8 @@
 
 ALCHEMY_DOMAIN = '.alchemy.com'
 
+EXECUTION_ENDPOINT_SYNC_POLL_INTERVAL = 0.1
+
 
 class WalletTask(BaseTask):
     async def process_block(self, interrupt_handler: InterruptHandler) -> None:
@@ -88,6 +91,14 @@ async def check_gas_price(high_priority: bool = False) -> bool:
     return await gas_manager.check_gas_price(high_priority)
 
 
+async def wait_for_execution_endpoints_synced(target_block: BlockNumber) -> None:
+    while True:
+        current_block = await execution_client.eth.block_number
+        if current_block >= target_block:
+            return
+        await asyncio.sleep(EXECUTION_ENDPOINT_SYNC_POLL_INTERVAL)
+
+
 def build_gas_manager() -> GasManager:
     min_effective_priority_fee_per_gas = settings.network_config.MIN_EFFECTIVE_PRIORITY_FEE_PER_GAS
     return GasManager(