feat: add submit and wait for transaction submission

snippets/multisign.py

@@ -2,13 +2,7 @@
 from xrpl.clients import JsonRpcClient
 from xrpl.models.requests import SubmitMultisigned
 from xrpl.models.transactions import AccountSet, SignerEntry, SignerListSet
-from xrpl.transaction import (
-    autofill,
-    autofill_and_sign,
-    multisign,
-    send_reliable_submission,
-    sign,
-)
+from xrpl.transaction import autofill, multisign, sign, submit_and_wait
 from xrpl.utils import str_to_hex
 from xrpl.wallet import generate_faucet_wallet
 
@@ -29,12 +23,9 @@
     signer_quorum=2,
     signer_entries=signer_entries,
 )
-signed_signer_list_set_tx = autofill_and_sign(signer_list_set_tx, master_wallet, client)
 
-print("Constructed SignerListSet and submitting it to the ledger...")
-signed_list_set_tx_response = send_reliable_submission(
-    signed_signer_list_set_tx, client
-)
+print("Constructing SignerListSet and submitting it to the ledger...")
+signed_list_set_tx_response = submit_and_wait(signer_list_set_tx, master_wallet, client)
 print("SignerListSet submitted, here's the response:")
 print(signed_list_set_tx_response)
 

snippets/partial_payment.py

@@ -3,7 +3,7 @@
 from xrpl.models.amounts import IssuedCurrencyAmount
 from xrpl.models.requests import AccountLines
 from xrpl.models.transactions import Payment, PaymentFlag, TrustSet
-from xrpl.transaction import autofill_and_sign, send_reliable_submission
+from xrpl.transaction import submit_and_wait
 from xrpl.wallet import generate_faucet_wallet
 
 # References
@@ -30,8 +30,7 @@
 )
 
 # Sign and autofill, then send transaction to the ledger
-signed_trust_set_tx = autofill_and_sign(trust_set_tx, wallet2, client)
-send_reliable_submission(signed_trust_set_tx, client)
+submit_and_wait(trust_set_tx, wallet2, client)
 
 # Both balances should be zero since nothing has been sent yet
 print("Balances after trustline is claimed:")
@@ -51,8 +50,7 @@
 )
 
 # Sign and autofill, then send transaction to the ledger
-signed_payment_tx = autofill_and_sign(payment_tx, wallet1, client)
-payment_response = send_reliable_submission(signed_payment_tx, client)
+payment_response = submit_and_wait(payment_tx, wallet1, client)
 print(payment_response)
 
 # Issuer (wallet1) should have -3840 FOO and destination (wallet2) should have 3840 FOO
@@ -86,8 +84,7 @@
 )
 
 # Sign and autofill, then send transaction to the ledger
-signed_partial_payment_tx = autofill_and_sign(partial_payment_tx, wallet2, client)
-partial_payment_response = send_reliable_submission(signed_partial_payment_tx, client)
+partial_payment_response = submit_and_wait(partial_payment_tx, wallet2, client)
 print(partial_payment_response)
 
 # Tried sending 4000 of 3840 FOO -> wallet1 and wallet2 should have 0 FOO

snippets/reliable_transaction_submission.py

@@ -3,7 +3,7 @@
 from xrpl.clients import JsonRpcClient
 from xrpl.models.requests import Tx
 from xrpl.models.transactions import Payment
-from xrpl.transaction import autofill_and_sign, send_reliable_submission
+from xrpl.transaction import submit_and_wait
 from xrpl.wallet import generate_faucet_wallet
 
 # References:
@@ -30,11 +30,8 @@
     destination=wallet2.classic_address,
 )
 
-# Sign and autofill the transaction (prepares it to be ready to submit)
-signed_payment_tx = autofill_and_sign(payment_tx, wallet1, client)
-
-# Submits transaction and waits for response (validated or rejected)
-payment_response = send_reliable_submission(signed_payment_tx, client)
+# Sign, autofill, submit transaction and waits for response (validated or rejected)
+payment_response = submit_and_wait(payment_tx, wallet1, client)
 print("Transaction was submitted")
 
 # Create a Transaction request to see transaction

snippets/send_escrow.py

@@ -5,7 +5,7 @@
 from xrpl.clients import JsonRpcClient
 from xrpl.models.requests import AccountObjects
 from xrpl.models.transactions import EscrowCreate, EscrowFinish
-from xrpl.transaction import autofill_and_sign, send_reliable_submission
+from xrpl.transaction.reliable_submission import submit_and_wait
 from xrpl.utils import datetime_to_ripple_time
 from xrpl.wallet import generate_faucet_wallet
 
@@ -37,8 +37,7 @@
     finish_after=finish_after,
 )
 
-signed_create_tx = autofill_and_sign(create_tx, wallet1, client)
-create_escrow_response = send_reliable_submission(signed_create_tx, client)
+create_escrow_response = submit_and_wait(create_tx, wallet1, client)
 print(create_escrow_response)
 
 # Create an AccountObjects request and have the client call it to see if escrow exists
@@ -55,8 +54,7 @@
     offer_sequence=create_escrow_response.result["Sequence"],
 )
 
-signed_finish_tx = autofill_and_sign(finish_tx, wallet1, client)
-send_reliable_submission(signed_finish_tx, client)
+submit_and_wait(finish_tx, wallet1, client)
 
 # If escrow went through successfully, 1000000 exchanged
 print("Balances of wallets after Escrow was sent:")

snippets/set_regular_key.py

@@ -2,7 +2,7 @@
 from xrpl.account import get_balance
 from xrpl.clients import JsonRpcClient
 from xrpl.models.transactions import Payment, SetRegularKey
-from xrpl.transaction import autofill_and_sign, send_reliable_submission
+from xrpl.transaction import submit_and_wait
 from xrpl.wallet import generate_faucet_wallet
 
 # References
@@ -28,8 +28,7 @@
     account=wallet1.classic_address, regular_key=regular_key_wallet.classic_address
 )
 
-signed_tx = autofill_and_sign(tx, wallet1, client)
-set_regular_key_response = send_reliable_submission(signed_tx, client)
+set_regular_key_response = submit_and_wait(tx, wallet1, client)
 
 print("Response for successful SetRegularKey tx:")
 print(set_regular_key_response)
@@ -42,8 +41,7 @@
     amount="1000",
 )
 
-signed_payment = autofill_and_sign(payment, regular_key_wallet, client)
-payment_response = send_reliable_submission(signed_payment, client)
+payment_response = submit_and_wait(payment, regular_key_wallet, client)
 
 print("Response for tx signed using Regular Key:")
 print(payment_response)

tests/integration/sugar/test_transaction.py

@@ -16,6 +16,7 @@
     get_transaction_from_hash,
     send_reliable_submission,
     sign,
+    submit_and_wait,
 )
 from xrpl.asyncio.transaction import (
     submit_transaction as submit_transaction_alias_async,
@@ -455,3 +456,76 @@ async def test_reliable_submission_no_last_ledger_sequence(self, client):
         signed_payment_transaction = await sign(payment_transaction, WALLET)
         with self.assertRaises(XRPLReliableSubmissionException):
             await send_reliable_submission(signed_payment_transaction, client)
+
+
+class TestSubmitAndWait(IntegrationTestCase):
+    @test_async_and_sync(
+        globals(),
+        [
+            "xrpl.transaction.submit_and_wait",
+            "xrpl.account.get_next_valid_seq_number",
+            "xrpl.ledger.get_fee",
+        ],
+    )
+    async def test_submit_and_wait_simple(self, client):
+        WALLET.sequence = await get_next_valid_seq_number(ACCOUNT, client)
+        account_set = AccountSet(
+            account=ACCOUNT,
+            sequence=WALLET.sequence,
+            set_flag=SET_FLAG,
+        )
+        await accept_ledger_async()
+        response = await submit_and_wait(account_set, WALLET, client)
+        self.assertTrue(response.result["validated"])
+        self.assertEqual(response.result["meta"]["TransactionResult"], "tesSUCCESS")
+        self.assertTrue(response.is_successful())
+        self.assertEqual(response.result["Fee"], await get_fee(client))
+        WALLET.sequence += 1
+
+    @test_async_and_sync(
+        globals(),
+        [
+            "xrpl.transaction.submit_and_wait",
+            "xrpl.account.get_next_valid_seq_number",
+            "xrpl.ledger.get_fee",
+        ],
+    )
+    async def test_submit_and_wait_payment(self, client):
+        WALLET.sequence = await get_next_valid_seq_number(ACCOUNT, client)
+        payment_dict = {
+            "account": ACCOUNT,
+            "sequence": WALLET.sequence,
+            "amount": "10",
+            "destination": DESTINATION,
+        }
+        payment_transaction = Payment.from_dict(payment_dict)
+        await accept_ledger_async()
+        response = await submit_and_wait(payment_transaction, WALLET, client)
+        self.assertTrue(response.result["validated"])
+        self.assertEqual(response.result["meta"]["TransactionResult"], "tesSUCCESS")
+        self.assertTrue(response.is_successful())
+        self.assertEqual(response.result["Fee"], await get_fee(client))
+        WALLET.sequence += 1
+
+    @test_async_and_sync(
+        globals(),
+        [
+            "xrpl.transaction.submit_and_wait",
+            "xrpl.account.get_next_valid_seq_number",
+            "xrpl.ledger.get_latest_validated_ledger_sequence",
+        ],
+    )
+    async def test_submit_and_wait_last_ledger_expiration(self, client):
+        WALLET.sequence = await get_next_valid_seq_number(ACCOUNT, client)
+        payment_dict = {
+            "account": ACCOUNT,
+            "sequence": WALLET.sequence,
+            "last_ledger_sequence": await get_latest_validated_ledger_sequence(client),
+            "fee": "10",
+            "amount": "100",
+            "destination": DESTINATION,
+        }
+        payment_transaction = Payment.from_dict(payment_dict)
+        await accept_ledger_async()
+        with self.assertRaises(XRPLReliableSubmissionException):
+            await submit_and_wait(payment_transaction, WALLET, client)

xrpl/asyncio/transaction/__init__.py

@@ -15,6 +15,7 @@
 from xrpl.asyncio.transaction.reliable_submission import (
     XRPLReliableSubmissionException,
     send_reliable_submission,
+    submit_and_wait,
 )
 
 __all__ = [
@@ -27,6 +28,7 @@
     "sign",
     "sign_and_submit",
     "submit",
+    "submit_and_wait",
     "submit_transaction",
     "transaction_json_to_binary_codec_form",
     "send_reliable_submission",

xrpl/asyncio/transaction/reliable_submission.py

@@ -6,12 +6,13 @@
 
 from xrpl.asyncio.clients import Client
 from xrpl.asyncio.ledger import get_latest_validated_ledger_sequence
-from xrpl.asyncio.transaction.main import submit
+from xrpl.asyncio.transaction.main import safe_sign_and_autofill_transaction, submit
 from xrpl.clients import XRPLRequestFailureException
 from xrpl.constants import XRPLException
 from xrpl.models.requests import Tx
 from xrpl.models.response import Response
 from xrpl.models.transactions.transaction import Transaction
+from xrpl.wallet.main import Wallet
 
 _LEDGER_CLOSE_TIME: Final[int] = 1
 
@@ -113,3 +114,32 @@ async def send_reliable_submission(
     return await _wait_for_final_transaction_outcome(
         transaction_hash, client, prelim_result, 0
     )
+
+
+async def submit_and_wait(
+    transaction: Transaction,
+    wallet: Wallet,
+    client: Client,
+    check_fee: bool = True,
+) -> Response:
+    """
+    Signs a transaction (locally, without trusting external rippled nodes), submits,
+    and verifies that it has been included in a validated ledger (or has errored
+    /will not be included for some reason).
+    `See Reliable Transaction Submission
+    <https://xrpl.org/reliable-transaction-submission.html>`_
+
+    Args:
+        transaction: the transaction to be signed and submitted.
+        wallet: the wallet with which to sign the transaction.
+        client: the network client with which to submit the transaction.
+        check_fee: whether to check if the fee is higher than the expected transaction
+            type fee. Defaults to True.
+
+    Returns:
+        The response from the ledger.
+    """
+    signed_transaction = await safe_sign_and_autofill_transaction(
+        transaction, wallet, client, check_fee
+    )
+    return await send_reliable_submission(signed_transaction, client)

xrpl/transaction/__init__.py

@@ -16,7 +16,10 @@
     submit_transaction,
 )
 from xrpl.transaction.multisign import multisign
-from xrpl.transaction.reliable_submission import send_reliable_submission
+from xrpl.transaction.reliable_submission import (
+    send_reliable_submission,
+    submit_and_wait,
+)
 
 __all__ = [
     "autofill",
@@ -28,6 +31,7 @@
     "sign",
     "sign_and_submit",
     "submit",
+    "submit_and_wait",
     "submit_transaction",
     "transaction_json_to_binary_codec_form",
     "send_reliable_submission",

xrpl/transaction/reliable_submission.py

@@ -5,9 +5,11 @@
 from xrpl.asyncio.transaction import (
     send_reliable_submission as async_send_reliable_submission,
 )
+from xrpl.asyncio.transaction import submit_and_wait as async_submit_and_wait
 from xrpl.clients.sync_client import SyncClient
 from xrpl.models.response import Response
 from xrpl.models.transactions.transaction import Transaction
+from xrpl.wallet.main import Wallet
 
 
 def send_reliable_submission(transaction: Transaction, client: SyncClient) -> Response:
@@ -30,3 +32,36 @@ def send_reliable_submission(transaction: Transaction, client: SyncClient) -> Re
         The response from a validated ledger.
     """
     return asyncio.run(async_send_reliable_submission(transaction, client))
+
+
+def submit_and_wait(
+    transaction: Transaction,
+    wallet: Wallet,
+    client: SyncClient,
+    check_fee: bool = True,
+) -> Response:
+    """
+    Signs a transaction (locally, without trusting external rippled nodes), submits,
+    and verifies that it has been included in a validated ledger (or has errored
+    /will not be included for some reason).
+    `See Reliable Transaction Submission
+    <https://xrpl.org/reliable-transaction-submission.html>`_
+
+    Args:
+        transaction: the transaction to be signed and submitted.
+        wallet: the wallet with which to sign the transaction.
+        client: the network client with which to submit the transaction.
+        check_fee: whether to check if the fee is higher than the expected transaction
+            type fee. Defaults to True.
+
+    Returns:
+        The response from the ledger.
+    """
+    return asyncio.run(
+        async_submit_and_wait(
+            transaction,
+            wallet,
+            client,
+            check_fee,
+        )
+    )