feat: Multi-Purpose Tokens (MPT)

CHANGELOG.md

@@ -8,6 +8,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 ## [[Unreleased]]
 
 ### Added
+- Support for the Multi-Purpose Tokens (MPT) amendment (XLS-33)
 - Add `include_deleted` to ledger_entry request
 
 ### BREAKING CHANGE:

pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "xrpl-py"
-version = "3.0.0"
+version = "4.0.0b3"
 description = "A complete Python library for interacting with the XRP ledger"
 readme = "README.md"
 repository = "https://github.com/XRPLF/xrpl-py"
@@ -50,6 +50,9 @@ coverage = "^7.2.7"
 Sphinx = "^7.1.2"
 poethepoet = "^0.29.0"
 
+[tool.poetry.group.dev.dependencies]
+packaging = "^24.1"
+
 [tool.isort]
 # Make sure that isort's settings line up with black
 profile = "black"

tests/integration/transactions/test_clawback.py

@@ -1,11 +1,11 @@
 from tests.integration.integration_test_case import IntegrationTestCase
-from tests.integration.it_utils import (
+from tests.integration.it_utils import (  # fund_wallet_async,
     fund_wallet,
     sign_and_reliable_submission_async,
     test_async_and_sync,
 )
 from tests.integration.reusable_values import WALLET
-from xrpl.models import (
+from xrpl.models import (  # MPTAmount,
     AccountSet,
     AccountSetAsfFlag,
     Clawback,
@@ -14,6 +14,14 @@
     TrustSet,
     TrustSetFlag,
 )
+
+# from xrpl.models.requests import LedgerEntry, Tx
+# from xrpl.models.requests.ledger_entry import MPToken
+# from xrpl.models.transactions import (
+#     MPTokenAuthorize,
+#     MPTokenIssuanceCreate,
+#     MPTokenIssuanceCreateFlag,
+# )
 from xrpl.wallet import Wallet
 
 HOLDER = Wallet.create()
@@ -71,3 +79,92 @@ async def test_basic_functionality(self, client):
             client,
         )
         self.assertTrue(response.is_successful())
+
+    # TODO: uncomment test when rippled Docker image supports MPT feature
+    # @test_async_and_sync(globals())
+    # async def test_mptoken(self, client):
+    #     wallet2 = Wallet.create()
+    #     await fund_wallet_async(wallet2)
+
+    #     tx = MPTokenIssuanceCreate(
+    #         account=WALLET.classic_address,
+    #         flags=MPTokenIssuanceCreateFlag.TF_MPT_CAN_CLAWBACK,
+    #     )
+
+    #     create_res = await sign_and_reliable_submission_async(
+    #         tx,
+    #         WALLET,
+    #         client,
+    #     )
+
+    #     self.assertTrue(create_res.is_successful())
+    #     self.assertEqual(create_res.result["engine_result"], "tesSUCCESS")
+
+    #     tx_hash = create_res.result["tx_json"]["hash"]
+
+    #     tx_res = await client.request(Tx(transaction=tx_hash))
+    #     mpt_issuance_id = tx_res.result["meta"]["mpt_issuance_id"]
+
+    #     auth_tx = MPTokenAuthorize(
+    #         account=wallet2.classic_address,
+    #         mptoken_issuance_id=mpt_issuance_id,
+    #     )
+
+    #     auth_res = await sign_and_reliable_submission_async(
+    #         auth_tx,
+    #         wallet2,
+    #         client,
+    #     )
+
+    #     self.assertTrue(auth_res.is_successful())
+    #     self.assertEqual(auth_res.result["engine_result"], "tesSUCCESS")
+
+    #     await sign_and_reliable_submission_async(
+    #         Payment(
+    #             account=WALLET.classic_address,
+    #             destination=wallet2.classic_address,
+    #             amount=MPTAmount(
+    #                 mpt_issuance_id=mpt_issuance_id, value="9223372036854775807"
+    #             ),
+    #         ),
+    #         WALLET,
+    #     )
+
+    #     ledger_entry_res = await client.request(
+    #         LedgerEntry(
+    #             mptoken=MPToken(
+    #                 mpt_issuance_id=mpt_issuance_id, account=wallet2.classic_address
+    #             )
+    #         )
+    #     )
+    #     self.assertEqual(
+    #         ledger_entry_res.result["node"]["MPTAmount"], "7fffffffffffffff"
+    #     )
+
+    #     # actual test - clawback
+    #     response = await sign_and_reliable_submission_async(
+    #         Clawback(
+    #             account=WALLET.classic_address,
+    #             amount=MPTAmount(
+    #                 mpt_issuance_id=mpt_issuance_id,
+    #                 value="500",
+    #             ),
+    #             holder=wallet2.classic_address,
+    #         ),
+    #         WALLET,
+    #         client,
+    #     )
+
+    #     self.assertTrue(response.is_successful())
+    #     self.assertEqual(auth_res.result["engine_result"], "tesSUCCESS")
+
+    #     ledger_entry_res = await client.request(
+    #         LedgerEntry(
+    #             mptoken=MPToken(
+    #                 mpt_issuance_id=mpt_issuance_id, account=wallet2.classic_address
+    #             )
+    #         )
+    #     )
+    #     self.assertEqual(
+    #         ledger_entry_res.result["node"]["MPTAmount"], "7ffffffffffffe0b"
+    #     )

tests/integration/transactions/test_mptoken_authorize.py

@@ -0,0 +1,114 @@
+# TODO: uncomment test module when rippled Docker image supports MPT feature
+# from tests.integration.integration_test_case import IntegrationTestCase
+# from tests.integration.it_utils import (
+#     fund_wallet_async,
+#     sign_and_reliable_submission_async,
+#     test_async_and_sync,
+# )
+# from tests.integration.reusable_values import WALLET
+# from xrpl.models.requests.account_objects import AccountObjects, AccountObjectType
+# from xrpl.models.requests.tx import Tx
+# from xrpl.models.transactions import (
+#     MPTokenAuthorize,
+#     MPTokenAuthorizeFlag,
+#     MPTokenIssuanceCreate,
+#     MPTokenIssuanceCreateFlag,
+# )
+# from xrpl.wallet.main import Wallet
+
+
+# class TestMPTokenAuthorize(IntegrationTestCase):
+#     @test_async_and_sync(globals())
+#     async def test_basic_functionality(self, client):
+#         tx = MPTokenIssuanceCreate(
+#             account=WALLET.classic_address,
+#             flags=MPTokenIssuanceCreateFlag.TF_MPT_REQUIRE_AUTH,
+#         )
+
+#         create_res = await sign_and_reliable_submission_async(
+#             tx,
+#             WALLET,
+#             client,
+#         )
+
+#         self.assertTrue(create_res.is_successful())
+#         self.assertEqual(create_res.result["engine_result"], "tesSUCCESS")
+
+#         tx_hash = create_res.result["tx_json"]["hash"]
+
+#         tx_res = await client.request(Tx(transaction=tx_hash))
+#         mpt_issuance_id = tx_res.result["meta"]["mpt_issuance_id"]
+
+#         # confirm MPTokenIssuance ledger object was created
+#         account_objects_response = await client.request(
+#             AccountObjects(account=WALLET.address,
+#               type=AccountObjectType.MPT_ISSUANCE)
+#         )
+
+#         # subsequent integration tests (sync/async + json/websocket) add one
+#         # MPTokenIssuance object to the account
+#         self.assertTrue(len(account_objects_response.result["account_objects"]) > 0)
+
+#         wallet2 = Wallet.create()
+#         await fund_wallet_async(wallet2)
+
+#         auth_tx = MPTokenAuthorize(
+#             account=wallet2.classic_address,
+#             mptoken_issuance_id=mpt_issuance_id,
+#         )
+
+#         auth_res = await sign_and_reliable_submission_async(
+#             auth_tx,
+#             wallet2,
+#             client,
+#         )
+
+#         self.assertTrue(auth_res.is_successful())
+#         self.assertEqual(auth_res.result["engine_result"], "tesSUCCESS")
+
+#         # confirm MPToken ledger object was created
+#         account_objects_response2 = await client.request(
+#             AccountObjects(account=wallet2.address, type=AccountObjectType.MPTOKEN)
+#         )
+
+#         # subsequent integration tests (sync/async + json/websocket) add one
+#         # MPToken object to the account
+#         self.assertTrue(len(account_objects_response2.result["account_objects"]) > 0)
+
+#         auth_tx2 = MPTokenAuthorize(
+#             account=WALLET.classic_address,
+#             mptoken_issuance_id=mpt_issuance_id,
+#             holder=wallet2.classic_address,
+#         )
+
+#         auth_res2 = await sign_and_reliable_submission_async(
+#             auth_tx2,
+#             WALLET,
+#             client,
+#         )
+
+#         self.assertTrue(auth_res2.is_successful())
+#         self.assertEqual(auth_res2.result["engine_result"], "tesSUCCESS")
+
+#         auth_tx3 = MPTokenAuthorize(
+#             account=wallet2.classic_address,
+#             mptoken_issuance_id=mpt_issuance_id,
+#             flags=MPTokenAuthorizeFlag.TF_MPT_UNAUTHORIZE,
+#         )
+
+#         auth_res3 = await sign_and_reliable_submission_async(
+#             auth_tx3,
+#             wallet2,
+#             client,
+#         )
+
+#         self.assertTrue(auth_res3.is_successful())
+#         self.assertEqual(auth_res3.result["engine_result"], "tesSUCCESS")
+
+#         # confirm MPToken ledger object is removed
+#         account_objects_response3 = await client.request(
+#             AccountObjects(account=wallet2.address, type=AccountObjectType.MPTOKEN)
+#         )
+
+#         # Should no longer hold an MPToken ledger object
+#         self.assertTrue(len(account_objects_response3.result["account_objects"]) == 0)

tests/integration/transactions/test_mptoken_issuance_create.py

@@ -0,0 +1,38 @@
+# TODO: uncomment test module when rippled Docker image supports MPT feature
+# from tests.integration.integration_test_case import IntegrationTestCase
+# from tests.integration.it_utils import (
+#     sign_and_reliable_submission_async,
+#     test_async_and_sync,
+# )
+# from tests.integration.reusable_values import WALLET
+# from xrpl.models.requests.account_objects import AccountObjects, AccountObjectType
+# from xrpl.models.transactions import MPTokenIssuanceCreate
+
+
+# class TestMPTokenIssuanceCreate(IntegrationTestCase):
+#     @test_async_and_sync(globals())
+#     async def test_basic_functionality(self, client):
+#         tx = MPTokenIssuanceCreate(
+#             account=WALLET.classic_address,
+#             maximum_amount="9223372036854775807",  # "7fffffffffffffff"
+#             asset_scale=2,
+#         )
+
+#         response = await sign_and_reliable_submission_async(
+#             tx,
+#             WALLET,
+#             client,
+#         )
+
+#         self.assertTrue(response.is_successful())
+#         self.assertEqual(response.result["engine_result"], "tesSUCCESS")
+
+#         # confirm MPTokenIssuance ledger object was created
+#         account_objects_response = await client.request(
+#             AccountObjects(account=WALLET.address,
+#             type=AccountObjectType.MPT_ISSUANCE)
+#         )
+
+#         # subsequent integration tests (sync/async + json/websocket) add one
+#         # MPTokenIssuance object to the account
+#         self.assertTrue(len(account_objects_response.result["account_objects"]) > 0)