Allow setting awaiting options for controller methods

multiversx_sdk/core/transaction_status.py

@@ -7,12 +7,14 @@ class TransactionStatus:
     is_completed: bool
     is_successful: bool
     is_failed: bool
+    is_not_executable_in_block: bool
 
     def __init__(self, status: str):
         self.status = status.lower()
         self.is_completed = self._is_status_completed()
         self.is_successful = self._is_status_successful()
         self.is_failed = self._is_status_failed()
+        self.is_not_executable_in_block = self._is_status_not_executable_in_block()
 
     def _is_status_completed(self) -> bool:
         return self._is_status_successful() or self._is_status_failed()
@@ -26,5 +28,7 @@ def _is_status_failed(self) -> bool:
             or self.status == "failed"
             or self.status == "unsuccessful"
             or self.status == "invalid"
-            or self.status == "not-executable-in-block"
         )
+
+    def _is_status_not_executable_in_block(self) -> bool:
+        return self.status == "not-executable-in-block"

multiversx_sdk/delegation/delegation_controller.py

@@ -27,7 +27,11 @@
 
 # fmt: off
 class INetworkProvider(Protocol):
-    def await_transaction_completed(self, transaction_hash: Union[str, bytes], options: Optional[AwaitingOptions] = None) -> TransactionOnNetwork:
+    def await_transaction_completed(
+        self,
+        transaction_hash: Union[str, bytes],
+        options: Optional[AwaitingOptions] = None,
+    ) -> TransactionOnNetwork:
         ...
 # fmt: on
 
@@ -80,9 +84,11 @@ def parse_create_new_delegation_contract(
         return self.parser.parse_create_new_delegation_contract(transaction_on_network)
 
     def await_completed_create_new_delegation_contract(
-        self, transaction_hash: Union[str, bytes]
+        self,
+        transaction_hash: Union[str, bytes],
+        options: Optional[AwaitingOptions] = None,
     ) -> list[CreateNewDelegationContractOutcome]:
-        transaction = self.network_provider.await_transaction_completed(transaction_hash)
+        transaction = self.network_provider.await_transaction_completed(transaction_hash, options)
         return self.parse_create_new_delegation_contract(transaction)
 
     def create_transaction_for_adding_nodes(
@@ -476,8 +482,12 @@ def create_transaction_for_delegating(
     def parse_delegate(self, transaction_on_network: TransactionOnNetwork) -> list[DelegateOutcome]:
         return self.parser.parse_delegate(transaction_on_network)
 
-    def await_completed_delegate(self, transaction_hash: Union[str, bytes]) -> list[DelegateOutcome]:
-        transaction = self.network_provider.await_transaction_completed(transaction_hash)
+    def await_completed_delegate(
+        self,
+        transaction_hash: Union[str, bytes],
+        options: Optional[AwaitingOptions] = None,
+    ) -> list[DelegateOutcome]:
+        transaction = self.network_provider.await_transaction_completed(transaction_hash, options)
         return self.parse_delegate(transaction)
 
     def create_transaction_for_claiming_rewards(
@@ -508,8 +518,12 @@ def create_transaction_for_claiming_rewards(
     def parse_claim_rewards(self, transaction_on_network: TransactionOnNetwork) -> list[ClaimRewardsOutcome]:
         return self.parser.parse_claim_rewards(transaction_on_network)
 
-    def await_completed_claim_rewards(self, transaction_hash: Union[str, bytes]) -> list[ClaimRewardsOutcome]:
-        transaction = self.network_provider.await_transaction_completed(transaction_hash)
+    def await_completed_claim_rewards(
+        self,
+        transaction_hash: Union[str, bytes],
+        options: Optional[AwaitingOptions] = None,
+    ) -> list[ClaimRewardsOutcome]:
+        transaction = self.network_provider.await_transaction_completed(transaction_hash, options)
         return self.parse_claim_rewards(transaction)
 
     def create_transaction_for_redelegating_rewards(
@@ -540,8 +554,12 @@ def create_transaction_for_redelegating_rewards(
     def parse_redelegate_rewards(self, transaction_on_network: TransactionOnNetwork) -> list[RedelegateRewardsOutcome]:
         return self.parser.parse_redelegate_rewards(transaction_on_network)
 
-    def await_completed_redelegate_rewards(self, transaction_hash: Union[str, bytes]) -> list[RedelegateRewardsOutcome]:
-        transaction = self.network_provider.await_transaction_completed(transaction_hash)
+    def await_completed_redelegate_rewards(
+        self,
+        transaction_hash: Union[str, bytes],
+        options: Optional[AwaitingOptions] = None,
+    ) -> list[RedelegateRewardsOutcome]:
+        transaction = self.network_provider.await_transaction_completed(transaction_hash, options)
         return self.parse_redelegate_rewards(transaction)
 
     def create_transaction_for_undelegating(
@@ -575,8 +593,12 @@ def create_transaction_for_undelegating(
     def parse_undelegate(self, transaction_on_network: TransactionOnNetwork) -> list[UndelegateOutcome]:
         return self.parser.parse_undelegate(transaction_on_network)
 
-    def await_completed_undelegate(self, transaction_hash: Union[str, bytes]) -> list[UndelegateOutcome]:
-        transaction = self.network_provider.await_transaction_completed(transaction_hash)
+    def await_completed_undelegate(
+        self,
+        transaction_hash: Union[str, bytes],
+        options: Optional[AwaitingOptions] = None,
+    ) -> list[UndelegateOutcome]:
+        transaction = self.network_provider.await_transaction_completed(transaction_hash, options)
         return self.parse_undelegate(transaction)
 
     def create_transaction_for_withdrawing(

multiversx_sdk/entrypoints/entrypoints.py

@@ -37,6 +37,7 @@
 )
 from multiversx_sdk.network_providers import ApiNetworkProvider, ProxyNetworkProvider
 from multiversx_sdk.network_providers.interface import INetworkProvider
+from multiversx_sdk.network_providers.resources import AwaitingOptions
 from multiversx_sdk.smart_contracts.smart_contract_controller import (
     SmartContractController,
 )
@@ -139,8 +140,12 @@ def send_transactions(self, transactions: list[Transaction]) -> tuple[int, list[
     def send_transaction(self, transaction: Transaction) -> bytes:
         return self.network_provider.send_transaction(transaction)
 
-    def await_transaction_completed(self, tx_hash: Union[str, bytes]) -> TransactionOnNetwork:
-        return self.network_provider.await_transaction_completed(tx_hash)
+    def await_transaction_completed(
+        self,
+        tx_hash: Union[str, bytes],
+        options: Optional[AwaitingOptions] = None,
+    ) -> TransactionOnNetwork:
+        return self.network_provider.await_transaction_completed(tx_hash, options)
 
     def get_transaction(self, tx_hash: Union[str, bytes]) -> TransactionOnNetwork:
         return self.network_provider.get_transaction(tx_hash)

multiversx_sdk/governance/governance_controller.py

@@ -100,8 +100,12 @@ def create_transaction_for_new_proposal(
     def parse_new_proposal(self, transaction_on_network: TransactionOnNetwork) -> list[NewProposalOutcome]:
         return self._parser.parse_new_proposal(transaction_on_network)
 
-    def await_completed_new_proposal(self, tx_hash: Union[str, bytes]) -> list[NewProposalOutcome]:
-        transaction = self._network_provider.await_transaction_completed(tx_hash)
+    def await_completed_new_proposal(
+        self,
+        tx_hash: Union[str, bytes],
+        options: Optional[AwaitingOptions] = None,
+    ) -> list[NewProposalOutcome]:
+        transaction = self._network_provider.await_transaction_completed(tx_hash, options)
         return self.parse_new_proposal(transaction)
 
     def create_transaction_for_voting(
@@ -132,8 +136,12 @@ def create_transaction_for_voting(
     def parse_vote(self, transaction_on_network: TransactionOnNetwork) -> list[VoteOutcome]:
         return self._parser.parse_vote(transaction_on_network)
 
-    def await_completed_vote(self, tx_hash: Union[str, bytes]) -> list[VoteOutcome]:
-        transaction = self._network_provider.await_transaction_completed(tx_hash)
+    def await_completed_vote(
+        self,
+        tx_hash: Union[str, bytes],
+        options: Optional[AwaitingOptions] = None,
+    ) -> list[VoteOutcome]:
+        transaction = self._network_provider.await_transaction_completed(tx_hash, options)
         return self.parse_vote(transaction)
 
     def create_transaction_for_closing_proposal(
@@ -163,8 +171,12 @@ def create_transaction_for_closing_proposal(
     def parse_close_proposal(self, transaction_on_network: TransactionOnNetwork) -> list[CloseProposalOutcome]:
         return self._parser.parse_close_proposal(transaction_on_network)
 
-    def await_completed_close_proposal(self, tx_hash: Union[str, bytes]) -> list[CloseProposalOutcome]:
-        transaction = self._network_provider.await_transaction_completed(tx_hash)
+    def await_completed_close_proposal(
+        self,
+        tx_hash: Union[str, bytes],
+        options: Optional[AwaitingOptions] = None,
+    ) -> list[CloseProposalOutcome]:
+        transaction = self._network_provider.await_transaction_completed(tx_hash, options)
         return self.parse_close_proposal(transaction)
 
     def create_transaction_for_clearing_ended_proposals(

multiversx_sdk/multisig/multisig_controller.py

@@ -118,8 +118,12 @@ def create_transaction_for_deploy(
     def parse_deploy(self, transaction_on_network: TransactionOnNetwork) -> SmartContractDeployOutcome:
         return self._parser.parse_deploy(transaction_on_network)
 
-    def await_completed_deploy(self, tx_hash: Union[str, bytes]) -> SmartContractDeployOutcome:
-        transaction = self._network_provider.await_transaction_completed(tx_hash)
+    def await_completed_deploy(
+        self,
+        tx_hash: Union[str, bytes],
+        options: Optional[AwaitingOptions] = None,
+    ) -> SmartContractDeployOutcome:
+        transaction = self._network_provider.await_transaction_completed(tx_hash, options)
         return self.parse_deploy(transaction)
 
     def create_transaction_for_deposit(
@@ -966,15 +970,23 @@ def get_action_valid_signer_count(self, contract: Address, action_id: int) -> in
     def parse_propose_action(self, transaction_on_network: TransactionOnNetwork) -> int:
         return self._parser.parse_propose_action(transaction_on_network)
 
-    def await_completed_execute_propose_any(self, tx_hash: Union[str, bytes]) -> int:
-        transaction = self._network_provider.await_transaction_completed(tx_hash)
+    def await_completed_execute_propose_any(
+        self,
+        tx_hash: Union[str, bytes],
+        options: Optional[AwaitingOptions] = None,
+    ) -> int:
+        transaction = self._network_provider.await_transaction_completed(tx_hash, options)
         return self.parse_propose_action(transaction)
 
     def parse_perform_action(self, transaction_on_network: TransactionOnNetwork) -> Optional[Address]:
         return self._parser.parse_perform_action(transaction_on_network)
 
-    def await_completed_perform_action(self, tx_hash: Union[str, bytes]) -> Optional[Address]:
-        transaction = self._network_provider.await_transaction_completed(tx_hash)
+    def await_completed_perform_action(
+        self,
+        tx_hash: Union[str, bytes],
+        options: Optional[AwaitingOptions] = None,
+    ) -> Optional[Address]:
+        transaction = self._network_provider.await_transaction_completed(tx_hash, options)
         return self.parse_perform_action(transaction)
 
     def create_transaction_for_execute(

multiversx_sdk/network_providers/transaction_awaiter_test.py

@@ -64,12 +64,11 @@ def test_await_status_not_executable(self):
                 TransactionStatus("pending"),
                 TimelinePointWait(40),
                 TransactionStatus("not-executable-in-block"),
-                TimelinePointMarkCompleted(),
             ],
         )
-        tx_from_network = self.watcher.await_completed(tx_hash)
+        tx_from_network = self.watcher.await_on_condition(tx_hash, lambda tx: tx.status.is_not_executable_in_block)
 
-        assert tx_from_network.status.is_failed
+        assert tx_from_network.status.is_not_executable_in_block
 
     @pytest.mark.networkInteraction
     def test_on_network(self):

multiversx_sdk/smart_contracts/smart_contract_controller.py

@@ -103,8 +103,12 @@ def create_transaction_for_deploy(
     def parse_deploy(self, transaction_on_network: TransactionOnNetwork) -> SmartContractDeployOutcome:
         return self.parser.parse_deploy(transaction_on_network)
 
-    def await_completed_deploy(self, transaction_hash: Union[str, bytes]) -> SmartContractDeployOutcome:
-        transaction = self.network_provider.await_transaction_completed(transaction_hash)
+    def await_completed_deploy(
+        self,
+        transaction_hash: Union[str, bytes],
+        options: Optional[AwaitingOptions] = None,
+    ) -> SmartContractDeployOutcome:
+        transaction = self.network_provider.await_transaction_completed(transaction_hash, options)
         return self.parse_deploy(transaction)
 
     def create_transaction_for_upgrade(
@@ -190,8 +194,12 @@ def parse_execute(
     ) -> ParsedSmartContractCallOutcome:
         return self.parser.parse_execute(transaction_on_network, function)
 
-    def await_completed_execute(self, transaction_hash: Union[str, bytes]) -> ParsedSmartContractCallOutcome:
-        transaction = self.network_provider.await_transaction_completed(transaction_hash)
+    def await_completed_execute(
+        self,
+        transaction_hash: Union[str, bytes],
+        options: Optional[AwaitingOptions] = None,
+    ) -> ParsedSmartContractCallOutcome:
+        transaction = self.network_provider.await_transaction_completed(transaction_hash, options)
         return self.parse_execute(transaction, transaction.function)
 
     def query(