Wait for block sync before get_withdrawable_assets

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

Author: cyc60

src/commands/internal/process_redeemer.py

@@ -412,9 +412,11 @@ async def redeem_positions(
         withdrawable = vault_to_withdrawable[position.vault]
 
         if withdrawable < assets_to_redeem and await is_meta_vault(position.vault):
-            await _redeem_meta_vault_sub_vaults(
+            last_receipt_block = await _redeem_meta_vault_sub_vaults(
                 vault_address=position.vault, assets=assets_to_redeem
             )
+            if last_receipt_block is not None:
+                await wait_for_execution_endpoints_synced(last_receipt_block)
             withdrawable = await get_withdrawable_assets(position.vault, harvest_params=None)
             vault_to_withdrawable[position.vault] = withdrawable
 
@@ -468,12 +470,17 @@ async def _startup_check() -> None:
 async def _redeem_meta_vault_sub_vaults(
     vault_address: ChecksumAddress,
     assets: Wei,
-) -> None:
+) -> BlockNumber | None:
     """Redeem from sub-vaults to bring a meta vault's withdrawable assets up to ``assets``.
 
     Builds a bottom-up redeem order so deepest nested meta vaults are redeemed first,
     then submits one redeemSubVaultsAssets transaction per entry. Failures abort the
     sequence; the caller refetches withdrawable to discover whatever progress was made.
+
+    Returns the block number of the last successful redeemSubVaultsAssets receipt, or
+    ``None`` if no transaction succeeded. The caller uses this as a sync barrier so
+    subsequent withdrawable reads cannot land on a fallback endpoint that has not
+    yet seen the redemptions.
     """
     try:
         redeem_order = await _build_meta_vault_redeem_order(vault_address, assets)
@@ -483,25 +490,29 @@ async def _redeem_meta_vault_sub_vaults(
             'Proceeding with current withdrawable assets.',
             vault_address,
         )
-        return
+        return None
 
+    last_receipt_block: BlockNumber | None = None
     for redeem_entry in redeem_order:
         try:
-            tx_hash = await os_token_redeemer_contract.redeem_sub_vaults_assets(
+            tx_hash, receipt_block = await os_token_redeemer_contract.redeem_sub_vaults_assets(
                 redeem_entry.vault, redeem_entry.assets
             )
             logger.info(
                 'redeemSubVaultsAssets confirmed for vault %s. Tx Hash: %s',
                 redeem_entry.vault,
                 tx_hash,
             )
+            last_receipt_block = receipt_block
         except (Web3Exception, RuntimeError, ValueError):
             logger.exception(
                 'redeemSubVaultsAssets failed for vault %s. '
                 'Proceeding with current withdrawable assets.',
                 redeem_entry.vault,
             )
-            return
+            return last_receipt_block
+
+    return last_receipt_block
 
 
 async def _build_meta_vault_redeem_order(

src/commands/tests/test_internal/test_process_redeemer.py

@@ -211,14 +211,22 @@ async def test_preserves_original_leaf_shares_in_call(self) -> None:
         assert submitted.shares_to_redeem == Wei(200)
 
     async def test_meta_vault_redeem_sub_vaults_when_short(self) -> None:
-        """Meta vault short on withdrawable triggers sub-vault redemption then refetches."""
+        """Meta vault short on withdrawable triggers sub-vault redemption then refetches.
+
+        After the redemption, the caller must wait for fallback execution endpoints to
+        catch up to the receipt block before re-reading withdrawable, otherwise a stale
+        read can underestimate available assets.
+        """
         pos = make_position(unprocessed_shares=500)
         # First call: short. Second call (post sub-vault redeem): plenty.
         get_withdrawable = AsyncMock(side_effect=[Wei(100), Wei(1000)])
 
         with (
             _mock_redeem_positions(withdrawable=get_withdrawable, is_meta_vault=True) as mocks,
-            patch(f'{MODULE}._redeem_meta_vault_sub_vaults', new=AsyncMock()) as mock_redeem_sub,
+            patch(
+                f'{MODULE}._redeem_meta_vault_sub_vaults',
+                new=AsyncMock(return_value=BlockNumber(900)),
+            ) as mock_redeem_sub,
         ):
             await redeem_positions(
                 all_positions=[pos],
@@ -229,17 +237,45 @@ async def test_meta_vault_redeem_sub_vaults_when_short(self) -> None:
             )
 
         mock_redeem_sub.assert_awaited_once()
+        # Sync barrier called with the receipt block before re-reading withdrawable.
+        mocks['wait_synced_mock'].assert_any_await(BlockNumber(900))
         assert get_withdrawable.await_count == 2
         assert _submitted_position(mocks).shares_to_redeem == Wei(500)
 
+    async def test_meta_vault_redeem_no_successful_tx_skips_sync_barrier(self) -> None:
+        """If sub-vault redemption submitted no successful tx, no sync barrier is needed."""
+        pos = make_position(unprocessed_shares=500)
+        get_withdrawable = AsyncMock(side_effect=[Wei(100), Wei(1000)])
+
+        with (
+            _mock_redeem_positions(withdrawable=get_withdrawable, is_meta_vault=True) as mocks,
+            patch(
+                f'{MODULE}._redeem_meta_vault_sub_vaults',
+                new=AsyncMock(return_value=None),
+            ),
+        ):
+            await redeem_positions(
+                all_positions=[pos],
+                os_token_positions=[pos],
+                queued_shares=10000,
+                converter=make_converter(100, 100),
+                tree_nonce=5,
+            )
+
+        # Only the post-position-submit sync, not a sub-vault sync.
+        mocks['wait_synced_mock'].assert_awaited_once_with(BlockNumber(123))
+
     async def test_meta_vault_redeem_still_short_partial_fill(self) -> None:
         """Sub-vault redemption helped but didn't fully cover — partial fill."""
         pos = make_position(unprocessed_shares=500)
         get_withdrawable = AsyncMock(side_effect=[Wei(100), Wei(300)])
 
         with (
             _mock_redeem_positions(withdrawable=get_withdrawable, is_meta_vault=True) as mocks,
-            patch(f'{MODULE}._redeem_meta_vault_sub_vaults', new=AsyncMock()),
+            patch(
+                f'{MODULE}._redeem_meta_vault_sub_vaults',
+                new=AsyncMock(return_value=BlockNumber(900)),
+            ),
         ):
             await redeem_positions(
                 all_positions=[pos],
@@ -261,7 +297,10 @@ async def test_meta_vault_cache_writeback_persists_across_positions(self) -> Non
 
         with (
             _mock_redeem_positions(withdrawable=get_withdrawable, is_meta_vault=True) as mocks,
-            patch(f'{MODULE}._redeem_meta_vault_sub_vaults', new=AsyncMock()),
+            patch(
+                f'{MODULE}._redeem_meta_vault_sub_vaults',
+                new=AsyncMock(return_value=BlockNumber(900)),
+            ),
         ):
             await redeem_positions(
                 all_positions=[pos1, pos2],
@@ -517,9 +556,12 @@ async def test_successful_redeem(self) -> None:
             ),
             patch(f'{MODULE}.os_token_redeemer_contract') as mock_redeemer,
         ):
-            mock_redeemer.redeem_sub_vaults_assets = AsyncMock(return_value='0xabc')
-            await _redeem_meta_vault_sub_vaults(vault_address=VAULT_1, assets=Wei(400))
+            mock_redeemer.redeem_sub_vaults_assets = AsyncMock(
+                return_value=('0xabc', BlockNumber(789))
+            )
+            result = await _redeem_meta_vault_sub_vaults(vault_address=VAULT_1, assets=Wei(400))
         mock_redeemer.redeem_sub_vaults_assets.assert_awaited_once_with(VAULT_1, Wei(400))
+        assert result == BlockNumber(789)
 
     @pytest.mark.parametrize('exc_class', [Web3Exception, RuntimeError, ValueError])
     async def test_failed_redeem_aborts_sequence(self, exc_class: type[Exception]) -> None:
@@ -537,8 +579,9 @@ async def test_failed_redeem_aborts_sequence(self, exc_class: type[Exception]) -
             patch(f'{MODULE}.os_token_redeemer_contract') as mock_redeemer,
         ):
             mock_redeemer.redeem_sub_vaults_assets = AsyncMock(side_effect=exc_class('fail'))
-            await _redeem_meta_vault_sub_vaults(vault_address=VAULT_1, assets=Wei(400))
+            result = await _redeem_meta_vault_sub_vaults(vault_address=VAULT_1, assets=Wei(400))
         mock_redeemer.redeem_sub_vaults_assets.assert_awaited_once_with(VAULT_2, Wei(200))
+        assert result is None
 
     async def test_unexpected_exception_propagates(self) -> None:
         """Exceptions outside the (Web3Exception, RuntimeError, ValueError) catch list propagate."""
@@ -554,7 +597,10 @@ async def test_unexpected_exception_propagates(self) -> None:
                 await _redeem_meta_vault_sub_vaults(vault_address=VAULT_1, assets=Wei(400))
 
     async def test_first_succeeds_second_fails(self) -> None:
-        """First sub-vault redemption succeeds; subsequent failure aborts after the second call."""
+        """First sub-vault redemption succeeds; subsequent failure aborts after the second call.
+
+        The block of the last successful tx is returned so the caller can sync endpoints.
+        """
         with (
             patch(
                 f'{MODULE}._build_meta_vault_redeem_order',
@@ -568,17 +614,18 @@ async def test_first_succeeds_second_fails(self) -> None:
             patch(f'{MODULE}.os_token_redeemer_contract') as mock_redeemer,
         ):
             mock_redeemer.redeem_sub_vaults_assets = AsyncMock(
-                side_effect=['0xabc', RuntimeError('fail')]
+                side_effect=[('0xabc', BlockNumber(700)), RuntimeError('fail')]
             )
-            await _redeem_meta_vault_sub_vaults(vault_address=VAULT_1, assets=Wei(400))
+            result = await _redeem_meta_vault_sub_vaults(vault_address=VAULT_1, assets=Wei(400))
 
         calls = mock_redeemer.redeem_sub_vaults_assets.call_args_list
         assert len(calls) == 2
         assert calls[0].args == (VAULT_2, Wei(200))
         assert calls[1].args == (VAULT_1, Wei(400))
+        assert result == BlockNumber(700)
 
     async def test_nested_meta_vault_all_succeed(self) -> None:
-        """Nested meta vault is redeemed before parent, in order."""
+        """Nested meta vault is redeemed before parent, in order; last receipt block returned."""
         with (
             patch(
                 f'{MODULE}._build_meta_vault_redeem_order',
@@ -591,13 +638,16 @@ async def test_nested_meta_vault_all_succeed(self) -> None:
             ),
             patch(f'{MODULE}.os_token_redeemer_contract') as mock_redeemer,
         ):
-            mock_redeemer.redeem_sub_vaults_assets = AsyncMock(return_value='0xabc')
-            await _redeem_meta_vault_sub_vaults(vault_address=VAULT_1, assets=Wei(400))
+            mock_redeemer.redeem_sub_vaults_assets = AsyncMock(
+                side_effect=[('0xabc', BlockNumber(700)), ('0xdef', BlockNumber(800))]
+            )
+            result = await _redeem_meta_vault_sub_vaults(vault_address=VAULT_1, assets=Wei(400))
 
         calls = mock_redeemer.redeem_sub_vaults_assets.call_args_list
         assert len(calls) == 2
         assert calls[0].args == (VAULT_2, Wei(200))
         assert calls[1].args == (VAULT_1, Wei(400))
+        assert result == BlockNumber(800)
 
     async def test_build_order_failure_returns_silently(self) -> None:
         """Failure to build the redeem order is logged and swallowed."""
@@ -609,8 +659,9 @@ async def test_build_order_failure_returns_silently(self) -> None:
             patch(f'{MODULE}.os_token_redeemer_contract') as mock_redeemer,
         ):
             mock_redeemer.redeem_sub_vaults_assets = AsyncMock()
-            await _redeem_meta_vault_sub_vaults(vault_address=VAULT_1, assets=Wei(400))
+            result = await _redeem_meta_vault_sub_vaults(vault_address=VAULT_1, assets=Wei(400))
         mock_redeemer.redeem_sub_vaults_assets.assert_not_called()
+        assert result is None
 
 
 class TestBuildMetaVaultRedeemOrder:

src/common/contracts.py

@@ -607,7 +607,7 @@ async def process_exit_queue(self) -> HexStr:
 
     async def redeem_sub_vaults_assets(
         self, vault_address: ChecksumAddress, assets_to_redeem: Wei
-    ) -> HexStr:
+    ) -> tuple[HexStr, BlockNumber]:
         tx_function = self.contract.functions.redeemSubVaultsAssets(vault_address, assets_to_redeem)
         tx_hash = await transaction_gas_wrapper(tx_function)
         tx_receipt = await self.execution_client.eth.wait_for_transaction_receipt(
@@ -617,7 +617,7 @@ async def redeem_sub_vaults_assets(
             raise RuntimeError(
                 f'redeemSubVaultsAssets transaction failed. Tx Hash: {Web3.to_hex(tx_hash)}'
             )
-        return Web3.to_hex(tx_hash)
+        return Web3.to_hex(tx_hash), tx_receipt['blockNumber']
 
 
 class ValidatorsCheckerContract(ContractWrapper):