fix: rectify STIssue codec (MPTCurrency case only) (#870)

ckeshava · coderabbitai[bot] · Patel-Raj11 · web-flow · commit fe2cf3ab2994 · 2025-09-25T14:35:33.000-07:00
* fix the errors in STIssue codec

* feature: allow xrpl-py integ tests to run on XRPL Devnet; This commit adds utility methods that aid in this effort

* add SAV integ test with MPToken as Vault asset

* fix: big-endian format to interpret the sequence number in MPTID

---------

Co-authored-by: coderabbitai[bot] &lt;136622811+coderabbitai[bot]@users.noreply.github.com&gt;
Co-authored-by: Raj Patel &lt;rajp@ripple.com&gt;
diff --git a/tests/integration/it_utils.py b/tests/integration/it_utils.py
@@ -39,6 +39,9 @@
 JSON_TESTNET_URL = "https://s.altnet.rippletest.net:51234"
 WEBSOCKET_TESTNET_URL = "wss://s.altnet.rippletest.net:51233"
 
+JSON_DEVNET_URL = "https://s.devnet.rippletest.net:51234/"
+WEBSOCKET_DEVNET_URL = "wss://s.devnet.rippletest.net:51233/"
+
 JSON_RPC_CLIENT = JsonRpcClient(JSON_RPC_URL)
 ASYNC_JSON_RPC_CLIENT = AsyncJsonRpcClient(JSON_RPC_URL)
 
@@ -51,16 +54,27 @@
 WEBSOCKET_TESTNET_CLIENT = WebsocketClient(WEBSOCKET_TESTNET_URL)
 ASYNC_WEBSOCKET_TESTNET_CLIENT = AsyncWebsocketClient(WEBSOCKET_TESTNET_URL)
 
-# (is_async, is_json, is_testnet) -> client
+JSON_RPC_DEVNET_CLIENT = JsonRpcClient(JSON_DEVNET_URL)
+ASYNC_JSON_RPC_DEVNET_CLIENT = AsyncJsonRpcClient(JSON_DEVNET_URL)
+
+WEBSOCKET_DEVNET_CLIENT = WebsocketClient(WEBSOCKET_DEVNET_URL)
+ASYNC_WEBSOCKET_DEVNET_CLIENT = AsyncWebsocketClient(WEBSOCKET_DEVNET_URL)
+
+# (is_async, is_json, is_testnet, use_devnet) -> client
 _CLIENTS = {
-    (True, True, True): ASYNC_JSON_RPC_TESTNET_CLIENT,
-    (True, True, False): ASYNC_JSON_RPC_CLIENT,
-    (True, False, True): ASYNC_WEBSOCKET_TESTNET_CLIENT,
-    (True, False, False): ASYNC_WEBSOCKET_CLIENT,
-    (False, True, True): JSON_RPC_TESTNET_CLIENT,
-    (False, True, False): JSON_RPC_CLIENT,
-    (False, False, True): WEBSOCKET_TESTNET_CLIENT,
-    (False, False, False): WEBSOCKET_CLIENT,
+    (True, True, True, False): ASYNC_JSON_RPC_TESTNET_CLIENT,
+    (True, True, False, False): ASYNC_JSON_RPC_CLIENT,
+    (True, False, True, False): ASYNC_WEBSOCKET_TESTNET_CLIENT,
+    (True, False, False, False): ASYNC_WEBSOCKET_CLIENT,
+    (False, True, True, False): JSON_RPC_TESTNET_CLIENT,
+    (False, True, False, False): JSON_RPC_CLIENT,
+    (False, False, True, False): WEBSOCKET_TESTNET_CLIENT,
+    (False, False, False, False): WEBSOCKET_CLIENT,
+    # Both use_testnet and use_devnet cannot be specified at the same time
+    (True, True, False, True): ASYNC_JSON_RPC_DEVNET_CLIENT,
+    (True, False, False, True): ASYNC_WEBSOCKET_DEVNET_CLIENT,
+    (False, True, False, True): JSON_RPC_DEVNET_CLIENT,
+    (False, False, False, True): WEBSOCKET_DEVNET_CLIENT,
 }
 
 MASTER_ACCOUNT = "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh"
@@ -156,6 +170,7 @@ def sign_and_reliable_submission(
     wallet: Wallet,
     client: SyncClient = JSON_RPC_CLIENT,
     check_fee: bool = True,
+    is_devnet_or_testnet=False,
 ) -> Response:
     modified_transaction = transaction
 
@@ -183,7 +198,10 @@ def sign_and_reliable_submission(
     response = submit_transaction(
         modified_transaction, wallet, client, check_fee=check_fee
     )
-    client.request(LEDGER_ACCEPT_REQUEST)
+
+    # On devnet or testnet, wait for the transaction to be validated
+    if not is_devnet_or_testnet:
+        client.request(LEDGER_ACCEPT_REQUEST)
     return response
 
 
@@ -193,6 +211,7 @@ async def sign_and_reliable_submission_async(
     wallet: Wallet,
     client: AsyncClient = ASYNC_JSON_RPC_CLIENT,
     check_fee: bool = True,
+    is_devnet_or_testnet=False,
 ) -> Response:
     modified_transaction = transaction
 
@@ -219,7 +238,10 @@ async def sign_and_reliable_submission_async(
     response = await submit_transaction_async(
         modified_transaction, wallet, client, check_fee=check_fee
     )
-    await client.request(LEDGER_ACCEPT_REQUEST)
+
+    # On devnet or testnet, wait for the transaction to be validated
+    if not is_devnet_or_testnet:
+        await client.request(LEDGER_ACCEPT_REQUEST)
     return response
 
 
@@ -253,16 +275,22 @@ async def accept_ledger_async(
     AsyncTestTimer(client, delay)
 
 
+# The _choose_client(_async)? methods are only used to send LEDGER_ACCEPT_REQUEST.
+# Hence, they are not applicable for devnet/testnet clients.
 def _choose_client(use_json_client: bool) -> SyncClient:
-    return cast(SyncClient, _CLIENTS[(False, use_json_client, False)])
+    return cast(SyncClient, _CLIENTS[(False, use_json_client, False, False)])
 
 
 def _choose_client_async(use_json_client: bool) -> AsyncClient:
-    return cast(AsyncClient, _CLIENTS[(True, use_json_client, False)])
+    return cast(AsyncClient, _CLIENTS[(True, use_json_client, False, False)])
 
 
-def _get_client(is_async: bool, is_json: bool, is_testnet: bool) -> Client:
-    return _CLIENTS[(is_async, is_json, is_testnet)]
+def _get_client(
+    is_async: bool, is_json: bool, is_testnet: bool, is_devnet: bool
+) -> Client:
+    if is_testnet and is_devnet:
+        raise ValueError("use_testnet and use_devnet are mutually exclusive")
+    return _CLIENTS[(is_async, is_json, is_testnet, is_devnet)]
 
 
 def test_async_and_sync(
@@ -271,6 +299,7 @@ def test_async_and_sync(
     websockets_only=False,
     num_retries=1,
     use_testnet=False,
+    use_devnet=False,
     async_only=False,
 ):
     def decorator(test_function):
@@ -345,18 +374,26 @@ def modified_test(self):
             if not websockets_only:
                 with self.subTest(version="async", client="json"):
                     asyncio.run(
-                        _run_async_test(self, _get_client(True, True, use_testnet), 1)
+                        _run_async_test(
+                            self, _get_client(True, True, use_testnet, use_devnet), 1
+                        )
                     )
                 if not async_only:
                     with self.subTest(version="sync", client="json"):
-                        _run_sync_test(self, _get_client(False, True, use_testnet), 2)
+                        _run_sync_test(
+                            self, _get_client(False, True, use_testnet, use_devnet), 2
+                        )
             with self.subTest(version="async", client="websocket"):
                 asyncio.run(
-                    _run_async_test(self, _get_client(True, False, use_testnet), 3)
+                    _run_async_test(
+                        self, _get_client(True, False, use_testnet, use_devnet), 3
+                    )
                 )
             if not async_only:
                 with self.subTest(version="sync", client="websocket"):
-                    _run_sync_test(self, _get_client(False, False, use_testnet), 4)
+                    _run_sync_test(
+                        self, _get_client(False, False, use_testnet, use_devnet), 4
+                    )
 
         return modified_test
 
diff --git a/tests/integration/transactions/test_single_asset_vault.py b/tests/integration/transactions/test_single_asset_vault.py
@@ -18,16 +18,137 @@
     VaultWithdraw,
 )
 from xrpl.models.amounts.issued_currency_amount import IssuedCurrencyAmount
+from xrpl.models.amounts.mpt_amount import MPTAmount
 from xrpl.models.currencies import IssuedCurrency
-from xrpl.models.requests import AccountObjects, LedgerEntry
+from xrpl.models.currencies.mpt_currency import MPTCurrency
+from xrpl.models.requests import AccountObjects, LedgerEntry, Tx
 from xrpl.models.requests.account_objects import AccountObjectType
 from xrpl.models.response import ResponseStatus
+from xrpl.models.transactions.mptoken_authorize import MPTokenAuthorize
+from xrpl.models.transactions.mptoken_issuance_create import (
+    MPTokenIssuanceCreate,
+    MPTokenIssuanceCreateFlag,
+)
 from xrpl.models.transactions.vault_create import WithdrawalPolicy
 from xrpl.utils import str_to_hex
 from xrpl.wallet import Wallet
 
 
 class TestSingleAssetVault(IntegrationTestCase):
+    @test_async_and_sync(globals())
+    async def test_vault_with_mptoken(self, client):
+        vault_owner = Wallet.create()
+        await fund_wallet_async(vault_owner)
+
+        # Create a MPToken
+        tx = MPTokenIssuanceCreate(
+            account=vault_owner.address,
+            flags=MPTokenIssuanceCreateFlag.TF_MPT_CAN_TRANSFER
+            + MPTokenIssuanceCreateFlag.TF_MPT_CAN_CLAWBACK,
+        )
+        response = await sign_and_reliable_submission_async(tx, vault_owner, client)
+        self.assertTrue(response.is_successful())
+        self.assertEqual(response.result["engine_result"], "tesSUCCESS")
+
+        # fetch the mpt_issuance_id
+        response = await client.request(
+            Tx(transaction=response.result["tx_json"]["hash"])
+        )
+        MPT_ISSUANCE_ID = response.result["meta"]["mpt_issuance_id"]
+
+        # Create a holder wallet to validate VaultDeposit+VaultWithdraw+VaultClawback
+        # transactions
+        holder_wallet = Wallet.create()
+        await fund_wallet_async(holder_wallet)
+
+        # holder provides authorization to hold the MPToken
+        tx = MPTokenAuthorize(
+            account=holder_wallet.address,
+            mptoken_issuance_id=MPT_ISSUANCE_ID,
+        )
+        response = await sign_and_reliable_submission_async(tx, holder_wallet, client)
+        self.assertEqual(response.status, ResponseStatus.SUCCESS)
+        self.assertEqual(response.result["engine_result"], "tesSUCCESS")
+
+        # transfer some MPToken to the holder wallet
+        tx = Payment(
+            account=vault_owner.address,
+            amount=MPTAmount(mpt_issuance_id=MPT_ISSUANCE_ID, value="100"),
+            destination=holder_wallet.address,
+        )
+        response = await sign_and_reliable_submission_async(tx, vault_owner, client)
+        self.assertEqual(response.status, ResponseStatus.SUCCESS)
+        self.assertEqual(response.result["engine_result"], "tesSUCCESS")
+
+        # Step-1: Create a vault
+        tx = VaultCreate(
+            account=vault_owner.address,
+            asset=MPTCurrency(mpt_issuance_id=MPT_ISSUANCE_ID),
+        )
+        response = await sign_and_reliable_submission_async(tx, vault_owner, client)
+        self.assertTrue(response.is_successful())
+        self.assertEqual(response.result["engine_result"], "tesSUCCESS")
+
+        print(response.result)
+
+        # Step-1.b: Verify the existence of the vault with account_objects RPC call
+        account_objects_response = await client.request(
+            AccountObjects(account=vault_owner.address, type=AccountObjectType.VAULT)
+        )
+        self.assertEqual(len(account_objects_response.result["account_objects"]), 1)
+
+        VAULT_ID = account_objects_response.result["account_objects"][0]["index"]
+
+        # Step-2: Update the characteristics of the vault with VaultSet transaction
+        tx = VaultSet(
+            account=vault_owner.address,
+            vault_id=VAULT_ID,
+            data=str_to_hex("auxilliary data pertaining to the vault"),
+        )
+        response = await sign_and_reliable_submission_async(tx, vault_owner, client)
+        self.assertEqual(response.status, ResponseStatus.SUCCESS)
+        self.assertEqual(response.result["engine_result"], "tesSUCCESS")
+
+        # Step-3: Execute a VaultDeposit transaction
+        tx = VaultDeposit(
+            account=holder_wallet.address,
+            vault_id=VAULT_ID,
+            amount=MPTAmount(mpt_issuance_id=MPT_ISSUANCE_ID, value="10"),
+        )
+        response = await sign_and_reliable_submission_async(tx, holder_wallet, client)
+        self.assertEqual(response.status, ResponseStatus.SUCCESS)
+        self.assertEqual(response.result["engine_result"], "tesSUCCESS")
+
+        # Step-4: Execute a VaultWithdraw transaction
+        tx = VaultWithdraw(
+            account=holder_wallet.address,
+            vault_id=VAULT_ID,
+            amount=MPTAmount(mpt_issuance_id=MPT_ISSUANCE_ID, value="5"),
+        )
+        response = await sign_and_reliable_submission_async(tx, holder_wallet, client)
+        self.assertEqual(response.status, ResponseStatus.SUCCESS)
+        self.assertEqual(response.result["engine_result"], "tesSUCCESS")
+
+        # Step-5: Execute a VaultClawback transaction
+        tx = VaultClawback(
+            account=vault_owner.address,
+            holder=holder_wallet.address,
+            vault_id=VAULT_ID,
+            amount=MPTAmount(mpt_issuance_id=MPT_ISSUANCE_ID, value="100"),
+        )
+        response = await sign_and_reliable_submission_async(tx, vault_owner, client)
+        self.assertEqual(response.status, ResponseStatus.SUCCESS)
+        self.assertEqual(response.result["engine_result"], "tesSUCCESS")
+
+        # Step-6: Delete the Vault with VaultDelete transaction
+        tx = VaultDelete(
+            account=vault_owner.address,
+            vault_id=VAULT_ID,
+        )
+        response = await sign_and_reliable_submission_async(tx, vault_owner, client)
+        self.assertEqual(response.status, ResponseStatus.SUCCESS)
+        self.assertEqual(response.result["engine_result"], "tesSUCCESS")
+
     @test_async_and_sync(globals())
     async def test_sav_lifecycle(self, client):
 
diff --git a/tests/unit/core/binarycodec/fixtures/data/codec-fixtures.json b/tests/unit/core/binarycodec/fixtures/data/codec-fixtures.json
@@ -5023,6 +5023,22 @@
         "AssetsMaximum": "1000",
         "WithdrawalPolicy": 1
       }
+    },
+    {
+      "binary": "120041210000F7E02400000557201B0000056D6840000000004C4B407321ED7FEAF5E19A09D903C13983D30BB7A67CBDA64AAB38A4C0DA6046644FFC0AF487744014B5CAC538F7094C2CCF1FB8A1E05068727F7A10441AA68C23CC50843EB558DA61E191430925890420EAE0F97E345F37F10D6FB89AA1E173EBF3C50B1095570D811443ABF2D7B13CE9EA5F6D2D87DCBFE078E2454C24031843ABF2D7B13CE9EA5F6D2D87DCBFE078E2454C24000000000000000000000000000000000000000155050000",
+      "json": {
+        "Account":"rfwFGsxok92FwnSTY4VcEpWXhARpNVrao4",
+        "Asset":{
+           "mpt_issuance_id":"0000055543ABF2D7B13CE9EA5F6D2D87DCBFE078E2454C24"
+        },
+        "Fee":"5000000",
+        "LastLedgerSequence":1389,
+        "NetworkID":63456,
+        "Sequence":1367,
+        "SigningPubKey":"ED7FEAF5E19A09D903C13983D30BB7A67CBDA64AAB38A4C0DA6046644FFC0AF487",
+        "TransactionType":"VaultCreate",
+        "TxnSignature":"14B5CAC538F7094C2CCF1FB8A1E05068727F7A10441AA68C23CC50843EB558DA61E191430925890420EAE0F97E345F37F10D6FB89AA1E173EBF3C50B1095570D"
+     }
     }
   ],
   "ledgerData": [
diff --git a/tests/unit/core/binarycodec/types/test_account_id.py b/tests/unit/core/binarycodec/types/test_account_id.py
@@ -22,3 +22,25 @@ def test_from_value_base58(self):
     def test_raises_invalid_value_type(self):
         invalid_value = 30
         self.assertRaises(XRPLBinaryCodecException, AccountID.from_value, invalid_value)
+
+    def test_special_account_ACCOUNT_ONE(self):
+        self.assertEqual(
+            AccountID.from_value("0000000000000000000000000000000000000001").to_json(),
+            "rrrrrrrrrrrrrrrrrrrrBZbvji",
+        )
+
+        self.assertEqual(
+            AccountID.from_value("rrrrrrrrrrrrrrrrrrrrBZbvji").to_hex(),
+            AccountID.from_value("0000000000000000000000000000000000000001").to_hex(),
+        )
+
+    def test_special_account_ACCOUNT_ZERO(self):
+        self.assertEqual(
+            AccountID.from_value("0000000000000000000000000000000000000000").to_json(),
+            "rrrrrrrrrrrrrrrrrrrrrhoLvTp",
+        )
+
+        self.assertEqual(
+            AccountID.from_value("rrrrrrrrrrrrrrrrrrrrrhoLvTp").to_hex(),
+            AccountID.from_value("0000000000000000000000000000000000000000").to_hex(),
+        )
diff --git a/tests/unit/core/binarycodec/types/test_issue.py b/tests/unit/core/binarycodec/types/test_issue.py
diff --git a/xrpl/core/binarycodec/types/issue.py b/xrpl/core/binarycodec/types/issue.py
