feat: add support for Batch amendment

.vscode/settings.json

@@ -11,6 +11,7 @@
     "keypair",
     "keypairs",
     "multisign",
+    "multisigned",
     "nftoken",
     "PATHSET",
     "rippletest",

tests/integration/sugar/test_transaction.py

@@ -6,22 +6,30 @@
 )
 from tests.integration.reusable_values import DESTINATION as DESTINATION_WALLET
 from tests.integration.reusable_values import WALLET
+from xrpl.asyncio.account import get_next_valid_seq_number
 from xrpl.asyncio.ledger import get_fee, get_latest_validated_ledger_sequence
 from xrpl.asyncio.transaction import (
     XRPLReliableSubmissionException,
     autofill,
     autofill_and_sign,
     sign,
+    sign_and_submit,
 )
 from xrpl.asyncio.transaction import submit as submit_transaction_alias_async
 from xrpl.asyncio.transaction import submit_and_wait
-from xrpl.asyncio.transaction.main import sign_and_submit
 from xrpl.clients import XRPLRequestFailureException
 from xrpl.core.addresscodec import classic_address_to_xaddress
-from xrpl.core.binarycodec.main import encode
+from xrpl.core.binarycodec import encode
 from xrpl.models.exceptions import XRPLException
 from xrpl.models.requests import ServerState, Tx
-from xrpl.models.transactions import AccountDelete, AccountSet, EscrowFinish, Payment
+from xrpl.models.transactions import (
+    AccountDelete,
+    AccountSet,
+    Batch,
+    DepositPreauth,
+    EscrowFinish,
+    Payment,
+)
 from xrpl.utils import xrp_to_drops
 
 ACCOUNT = WALLET.address
@@ -249,6 +257,38 @@ async def test_networkid_reserved_networks(self, client):
         self.assertIsNone(transaction.network_id)
         self.assertEqual(client.network_id, 1)
 
+    @test_async_and_sync(
+        globals(),
+        ["xrpl.transaction.autofill", "xrpl.account.get_next_valid_seq_number"],
+    )
+    async def test_batch_autofill(self, client):
+        tx = Batch(
+            account="rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
+            raw_transactions=[
+                DepositPreauth(
+                    account=WALLET.address,
+                    authorize="rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
+                ),
+                DepositPreauth(
+                    account=WALLET.address,
+                    authorize="rf1BiGeXwwQoi8Z2ueFYTEXSwuJYfV2Jpn",
+                ),
+            ],
+        )
+        transaction = await autofill(tx, client)
+        self.assertEqual(len(transaction.tx_ids), 2)
+
+        sequence = await get_next_valid_seq_number(WALLET.address, client)
+        for i in range(len(transaction.raw_transactions)):
+            raw_tx = transaction.raw_transactions[i]
+            self.assertIsNotNone(raw_tx.batch_txn)
+            self.assertEqual(
+                raw_tx.batch_txn.outer_account, "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh"
+            )
+            self.assertEqual(raw_tx.batch_txn.sequence, sequence + i)
+            self.assertEqual(raw_tx.batch_txn.batch_index, i)
+            self.assertEqual(raw_tx.get_hash(), transaction.tx_ids[i])
+
 
 class TestSubmitAndWait(IntegrationTestCase):
     @test_async_and_sync(

tests/unit/models/transactions/test_transaction.py

@@ -1,8 +1,9 @@
 from unittest import TestCase
 
 from xrpl.asyncio.transaction.main import sign
+from xrpl.core.addresscodec.main import classic_address_to_xaddress
 from xrpl.models.exceptions import XRPLModelException
-from xrpl.models.transactions import AccountSet, OfferCreate, Payment
+from xrpl.models.transactions import AccountSet, DepositPreauth, OfferCreate, Payment
 from xrpl.models.transactions.transaction import Transaction
 from xrpl.models.transactions.types.transaction_type import TransactionType
 from xrpl.transaction.multisign import multisign
@@ -158,8 +159,19 @@ def test_is_signed_for_multisigned_transaction(self):
         multisigned_tx = multisign(tx, [tx_1, tx_2])
         self.assertTrue(multisigned_tx.is_signed())
 
+    def test_multisigned_transaction_xaddress(self):
+        tx = DepositPreauth(
+            account=classic_address_to_xaddress(_WALLET.address, 1, False),
+            authorize=classic_address_to_xaddress(_ACCOUNT, 1, False),
+        )
+        tx_1 = sign(tx, _FIRST_SIGNER, multisign=True)
+        tx_2 = sign(tx, _SECOND_SIGNER, multisign=True)
+
+        multisigned_tx = multisign(tx, [tx_1, tx_2])
+        self.assertTrue(multisigned_tx.is_signed())
+
     # test the usage  of DeliverMax field in Payment transactions
-    def test_payment_txn_API_no_deliver_max(self):
+    def test_payment_txn_api_no_deliver_max(self):
         delivered_amount = "200000"
         payment_tx_json = {
             "Account": "rGWTUVmm1fB5QUjMYn8KfnyrFNgDiD9H9e",
@@ -175,7 +187,7 @@ def test_payment_txn_API_no_deliver_max(self):
         payment_txn = Payment.from_xrpl(payment_tx_json)
         self.assertEqual(delivered_amount, payment_txn.to_dict()["amount"])
 
-    def test_payment_txn_API_no_amount(self):
+    def test_payment_txn_api_no_amount(self):
         delivered_amount = "200000"
         payment_tx_json = {
             "Account": "rGWTUVmm1fB5QUjMYn8KfnyrFNgDiD9H9e",
@@ -191,7 +203,7 @@ def test_payment_txn_API_no_amount(self):
         payment_txn = Payment.from_xrpl(payment_tx_json)
         self.assertEqual(delivered_amount, payment_txn.to_dict()["amount"])
 
-    def test_payment_txn_API_different_amount_and_deliver_max(self):
+    def test_payment_txn_api_different_amount_and_deliver_max(self):
         payment_tx_json = {
             "Account": "rGWTUVmm1fB5QUjMYn8KfnyrFNgDiD9H9e",
             "Destination": "rw71Qs1UYQrSQ9hSgRohqNNQcyjCCfffkQ",
@@ -207,7 +219,7 @@ def test_payment_txn_API_different_amount_and_deliver_max(self):
         with self.assertRaises(XRPLModelException):
             Payment.from_xrpl(payment_tx_json)
 
-    def test_payment_txn_API_identical_amount_and_deliver_max(self):
+    def test_payment_txn_api_identical_amount_and_deliver_max(self):
         delivered_amount = "200000"
         payment_tx_json = {
             "Account": "rGWTUVmm1fB5QUjMYn8KfnyrFNgDiD9H9e",

tools/generate_tx_models.py

@@ -26,7 +26,7 @@ def _parse_rippled_source(
     folder: str,
 ) -> Tuple[Dict[str, List[str]], Dict[str, List[Tuple[str, ...]]]]:
     # Get SFields
-    sfield_cpp = _read_file(os.path.join(folder, "src/ripple/protocol/impl/SField.cpp"))
+    sfield_cpp = _read_file(os.path.join(folder, "src/libxrpl/protocol/SField.cpp"))
     sfield_hits = re.findall(
         r'^ *CONSTRUCT_[^\_]+_SFIELD *\( *[^,\n]*,[ \n]*"([^\"\n ]+)"[ \n]*,[ \n]*'
         + r"([^, \n]+)[ \n]*,[ \n]*([0-9]+)(,.*?(notSigning))?",
@@ -37,7 +37,7 @@ def _parse_rippled_source(
 
     # Get TxFormats
     tx_formats_cpp = _read_file(
-        os.path.join(folder, "src/ripple/protocol/impl/TxFormats.cpp")
+        os.path.join(folder, "src/libxrpl/protocol/TxFormats.cpp")
     )
     tx_formats_hits = re.findall(
         r"^ *add\(jss::([^\"\n, ]+),[ \n]*tt[A-Z_]+,[ \n]*{[ \n]*(({sf[A-Za-z0-9]+, "
@@ -102,6 +102,7 @@ def _main(
     existing_library_txs = {m.value for m in TransactionType} | {
         m.value for m in PseudoTransactionType
     }
+    print(sorted(existing_library_txs))
     for tx in tx_formats:
         if tx not in existing_library_txs:
             txs_to_add.append((tx, _key_to_json(tx)))
@@ -130,7 +131,7 @@ def _generate_param_line(param: str, is_required: bool) -> str:
         param_lines.sort(key=lambda x: "REQUIRED" not in x)
         params = "\n".join(param_lines)
         model = f"""@require_kwargs_on_init
-@dataclass(frozen=True,  **KW_ONLY_DATACLASS)
+@dataclass(frozen=True, **KW_ONLY_DATACLASS)
 class {tx}(Transaction):
     \"\"\"Represents a {tx} transaction.\"\"\"
 
@@ -184,6 +185,8 @@ class {tx}(Transaction):
 
 
 if __name__ == "__main__":
+    if len(sys.argv) < 2:
+        print("Usage: poetry run python generate_tx_models.py path/to/rippled")
     folder = sys.argv[1]
     sfields, tx_formats = _parse_rippled_source(folder)
     _main(sfields, tx_formats)

xrpl/asyncio/transaction/main.py

@@ -1,8 +1,9 @@
 """High-level transaction methods with XRPL transactions."""
+
 import math
-from typing import Any, Dict, Optional, cast
+from typing import Any, Dict, List, Optional, Tuple, cast
 
-from typing_extensions import Final
+from typing_extensions import Final, TypeVar
 
 from xrpl.asyncio.account import get_next_valid_seq_number
 from xrpl.asyncio.clients import Client, XRPLRequestFailureException
@@ -14,6 +15,7 @@
 from xrpl.models.requests import ServerInfo, ServerState, SubmitOnly
 from xrpl.models.response import Response
 from xrpl.models.transactions import EscrowFinish
+from xrpl.models.transactions.batch import Batch
 from xrpl.models.transactions.transaction import Signer, Transaction
 from xrpl.models.transactions.transaction import (
     transaction_json_to_binary_codec_form as model_transaction_to_binary_codec,
@@ -85,11 +87,12 @@ def sign(
     Returns:
         The signed transaction blob.
     """
+    transaction_json = _prepare_transaction(transaction)
     if multisign:
         signature = keypairs_sign(
             bytes.fromhex(
                 encode_for_multisigning(
-                    transaction.to_xrpl(),
+                    transaction_json,
                     wallet.address,
                 )
             ),
@@ -105,7 +108,7 @@ def sign(
         ]
         return Transaction.from_dict(tx_dict)
 
-    transaction_json = _prepare_transaction(transaction, wallet)
+    transaction_json["SigningPubKey"] = wallet.public_key
     serialized_for_signing = encode_for_signing(transaction_json)
     serialized_bytes = bytes.fromhex(serialized_for_signing)
     signature = keypairs_sign(serialized_bytes, wallet.private_key)
@@ -174,10 +177,7 @@ async def submit(
     raise XRPLRequestFailureException(response.result)
 
 
-def _prepare_transaction(
-    transaction: Transaction,
-    wallet: Wallet,
-) -> Dict[str, Any]:
+def _prepare_transaction(transaction: Transaction) -> Dict[str, Any]:
     """
     Prepares a Transaction by converting it to a JSON-like dictionary, converting the
     field names to CamelCase. If a Client is provided, then it also autofills any
@@ -192,10 +192,13 @@ def _prepare_transaction(
 
     Raises:
         XRPLException: if both LastLedgerSequence and `ledger_offset` are provided, or
-            if an address tag is provided that does not match the X-Address tag.
+            if an address tag is provided that does not match the X-Address tag, or if
+            attempting to directly sign a Batch inner transaction.
     """
+    if transaction.batch_txn is not None:
+        raise XRPLException("Cannot directly sign a batch inner transaction.")
+
     transaction_json = transaction.to_xrpl()
-    transaction_json["SigningPubKey"] = wallet.public_key
 
     _validate_account_xaddress(transaction_json, "Account", "SourceTag")
     if "Destination" in transaction_json:
@@ -212,9 +215,12 @@ def _prepare_transaction(
     return transaction_json
 
 
+T = TypeVar("T", bound=Transaction, default=Transaction)
+
+
 async def autofill(
-    transaction: Transaction, client: Client, signers_count: Optional[int] = None
-) -> Transaction:
+    transaction: T, client: Client, signers_count: Optional[int] = None
+) -> T:
     """
     Autofills fields in a transaction. This will set `sequence`, `fee`, and
     `last_ledger_sequence` according to the current state of the server this Client is
@@ -244,7 +250,12 @@ async def autofill(
     if "last_ledger_sequence" not in transaction_json:
         ledger_sequence = await get_latest_validated_ledger_sequence(client)
         transaction_json["last_ledger_sequence"] = ledger_sequence + _LEDGER_OFFSET
-    return Transaction.from_dict(transaction_json)
+    if transaction.transaction_type == TransactionType.BATCH:
+        inner_txs, tx_ids = await _autofill_batch(client, cast(Batch, transaction))
+        transaction_json["raw_transactions"] = inner_txs
+        if "tx_ids" not in transaction_json:
+            transaction_json["tx_ids"] = tx_ids
+    return cast(T, Transaction.from_dict(transaction_json))
 
 
 async def _get_network_id_and_build_version(client: Client) -> None:
@@ -375,7 +386,7 @@ def _convert_to_classic_address(json: Dict[str, Any], field: str) -> None:
         field: the field in `json` that may contain an X-Address
     """
     if field in json and is_valid_xaddress(json[field]):
-        json[field] = xaddress_to_classic_address(json[field])
+        json[field] = xaddress_to_classic_address(json[field])[0]
 
 
 def transaction_json_to_binary_codec_form(dictionary: Dict[str, Any]) -> Dict[str, Any]:
@@ -482,3 +493,38 @@ async def _fetch_owner_reserve_fee(client: Client) -> int:
     server_state = await client._request_impl(ServerState())
     fee = server_state.result["state"]["validated_ledger"]["reserve_inc"]
     return int(fee)
+
+
+async def _autofill_batch(
+    client: Client, transaction: Batch
+) -> Tuple[List[Transaction], List[str]]:
+    account_sequences: Dict[str, int] = {}
+    batch_index = 0
+    tx_ids: List[str] = []
+    inner_txs: List[Transaction] = []
+
+    for raw_txn in transaction.raw_transactions:
+        if raw_txn.batch_txn is not None:
+            inner_txs.append(raw_txn)
+            continue
+
+        batch_txn: Dict[str, Any] = {"outer_account": transaction.account}
+
+        if raw_txn.account in account_sequences:
+            batch_txn["sequence"] = account_sequences[raw_txn.account]
+            account_sequences[raw_txn.account] += 1
+        else:
+            sequence = await get_next_valid_seq_number(raw_txn.account, client)
+            account_sequences[raw_txn.account] = sequence + 1
+            batch_txn["sequence"] = sequence
+
+        batch_txn["batch_index"] = batch_index
+        batch_index += 1
+
+        raw_txn_dict = raw_txn.to_dict()
+        raw_txn_dict["batch_txn"] = batch_txn
+        new_raw_txn = Transaction.from_dict(raw_txn_dict)
+        inner_txs.append(new_raw_txn)
+        tx_ids.append(new_raw_txn.get_hash())
+
+    return inner_txs, tx_ids