XLS-80d Permissioned Domains

.ci-config/rippled.cfg

@@ -182,6 +182,18 @@ PriceOracle
 fixEmptyDID
 fixXChainRewardRounding
 fixPreviousTxnID
+fixAMMv1_1
+Credentials
+NFTokenMintOffer
+fixNFTokenPageLinks
+fixInnerObjTemplate2
+fixEnforceNFTokenTrustline
+fixReducedOffersV2
+InvariantsV1_1
+MPTokensV1
+AMMv1_2
+AMMClawback
+PermissionedDomains
 
 # This section can be used to simulate various FeeSettings scenarios for rippled node in standalone mode
 [voting]

.github/workflows/integration_test.yml

@@ -2,7 +2,7 @@ name: Integration test
 
 env:
   POETRY_VERSION: 1.8.3
-  RIPPLED_DOCKER_IMAGE: rippleci/rippled:2.2.0-b3
+  RIPPLED_DOCKER_IMAGE: rippleci/rippled:2.3.0-rc1
 
 on:
   push:
@@ -32,7 +32,8 @@ jobs:
 
       - name: Run docker in background
         run: |
-          docker run --detach --rm --name rippled-service -p 5005:5005 -p 6006:6006 --volume "${{ github.workspace }}/.ci-config/":"/opt/ripple/etc/" --health-cmd="wget localhost:6006 || exit 1" --health-interval=5s --health-retries=10 --health-timeout=2s --env GITHUB_ACTIONS=true --env CI=true ${{ env.RIPPLED_DOCKER_IMAGE }} /opt/ripple/bin/rippled -a --conf /opt/ripple/etc/rippled.cfg
+          docker run -dit -p 5005:5005 -p 6006:6006 -v "${{ github.workspace }}/.ci-config/":/etc/opt/ripple/ --name rippled_standalone --health-cmd="rippled server_info || exit 1" --health-interval=5s --health-retries=10 --health-timeout=2s --env GITHUB_ACTIONS=true --env CI=true --entrypoint bash ${{ env.RIPPLED_DOCKER_IMAGE }}
+          docker exec -d rippled_standalone rippled -a
 
       - name: Install poetry
         if: steps.cache-poetry.outputs.cache-hit != 'true'
@@ -60,4 +61,4 @@ jobs:
 
       - name: Stop docker container
         if: always()
-        run: docker stop rippled-service
+        run: docker stop rippled_standalone

CHANGELOG.md

@@ -9,9 +9,11 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ### Added
 - Add `include_deleted` to ledger_entry request
+- Add support for the `PermissionedDomains` feature
 
 ### BREAKING CHANGE:
 - Remove Python 3.7 support to fix dependency installation and use 3.8 as new default.
+- Remove the AccountObjectType enum. Instead, use the LedgerEntryType enum, this reduces redundancy in the codebase.
 
 ### Fixed
 - Grab the FeeSettings values from the latest validated ledger. Remove hard-coded reference to 10 drops as the reference transaction cost.
@@ -91,7 +93,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 ## [2.0.0] - 2023-07-05
 ### BREAKING CHANGE
 - The default signing algorithm in the `Wallet` was changed from secp256k1 to ed25519
-- 
+-
 ### Added:
 - Wallet support for regular key compatibility
 - Added new ways of wallet generation: `from_seed`, `from_secret`, `from_entropy`, `from_secret_numbers`

CONTRIBUTING.md

@@ -91,16 +91,19 @@ To run integration tests, you'll need a standalone rippled node running with WS
 
 ```bash
 docker run -p 5005:5005 -p 6006:6006 --interactive -t --volume $PWD/.ci-config:/opt/ripple/etc/ --platform linux/amd64 rippleci/rippled:2.2.0-b3 /opt/ripple/bin/rippled -a --conf /opt/ripple/etc/rippled.cfg
+
+docker run -dit -p 5005:5005 -p 6006:6006 -v $PWD/.ci-config/:/etc/opt/ripple/ --name rippled_standalone --entrypoint bash rippleci/rippled:develop
+docker exec -d rippled_standalone rippled -a
 ```
 
 Breaking down the command:
 * `docker run -p 5005:5005 -p 6006:6006` starts a Docker container with an open port for admin JsonRPC and WebSocket requests.
-* `--interactive` allows you to interact with the container.
+* `-it` allows you to interact with the container.
+* `-d` runs the docker container in detached mode. The container will run in the background and developer gets back control of the terminal
 * `-t` starts a terminal in the container for you to send commands to.
-* `--volume $PWD/.ci-config:/config/` identifies the `rippled.cfg` and `validators.txt` to import. It must be an absolute path, so we use `$PWD` instead of `./`.
-* `xrpllabsofficial/xrpld:1.12.0` is an image that is regularly updated with the latest `rippled` releases and can be found here: https://github.com/WietseWind/docker-rippled
+* `--volume $PWD/.ci-config:/etc/opt/ripple/` mounts the directories as indicated. It must be an absolute path, so we use `$PWD` instead of `./`. `rippled` software searches the location `/etc/opt/ripple/` (default behavior) for the config files. Hence there is no need to explicitly specify the config-file path.
+* `rippleci/rippled:develop` is an image that is regularly updated with the latest build of the `develop` branch of `rippled`.
 * `-a` starts `rippled` in standalone mode
-* `--start` signals to start `rippled` with the specified amendments in `rippled.cfg` enabled immediately instead of voting for 2 weeks on them.
 
 Then to actually run the tests, run the command:
 

tests/integration/reusable_values.py

@@ -13,6 +13,8 @@
     XRP,
     AMMDeposit,
     AMMDepositFlag,
+    CredentialAccept,
+    CredentialCreate,
     IssuedCurrencyAmount,
     OfferCreate,
     PaymentChannelCreate,
@@ -21,6 +23,7 @@
     XChainBridge,
     XChainCreateBridge,
 )
+from xrpl.utils import str_to_hex
 from xrpl.wallet import Wallet
 
 
@@ -95,6 +98,26 @@ async def _set_up_reusable_values():
     amm_asset2 = setup_amm_pool_res["asset2"]
     amm_issuer_wallet = setup_amm_pool_res["issuer_wallet"]
 
+    # Create and accept one credential; This is used in the PermissionedDomain tests
+    cred_type: str = str_to_hex("IdentityDocument")
+    await sign_and_reliable_submission_async(
+        CredentialCreate(
+            account=wallet.address,
+            subject=destination.address,
+            credential_type=cred_type,
+        ),
+        wallet,
+    )
+
+    credential_accept_txn_response = await sign_and_reliable_submission_async(
+        CredentialAccept(
+            issuer=wallet.address,
+            credential_type=cred_type,
+            account=destination.address,
+        ),
+        destination,
+    )
+
     return (
         wallet,
         destination,
@@ -106,6 +129,7 @@ async def _set_up_reusable_values():
         amm_asset2,
         amm_issuer_wallet,
         bridge,
+        credential_accept_txn_response,
     )
 
 
@@ -149,4 +173,5 @@ async def setup_amm_pool(
     AMM_ASSET2,
     AMM_ISSUER_WALLET,
     BRIDGE,
+    CREDENTIAL_ACCEPT_RESPONSE,
 ) = asyncio.run(_set_up_reusable_values())

tests/integration/transactions/test_credential.py

@@ -0,0 +1,121 @@
+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 DESTINATION, WALLET
+from xrpl.models import AccountObjects, LedgerEntryType
+from xrpl.models.requests.ledger_entry import Credential, LedgerEntry
+from xrpl.models.response import ResponseStatus
+from xrpl.models.transactions.credential_accept import CredentialAccept
+from xrpl.models.transactions.credential_create import CredentialCreate
+from xrpl.models.transactions.credential_delete import CredentialDelete
+from xrpl.utils import str_to_hex
+
+_URI = "www.my-id.com/username"
+
+
+def is_cred_object_present(
+    result: dict, issuer: str, subject: str, cred_type: str
+) -> bool:
+    """
+    Args:
+        result: JSON response from account_objects RPC
+        issuer: Address of the credential issuer
+        subject: Address of the credential subject
+        cred_type: Type of the credential
+
+    Returns:
+        bool: True if credential exists, False otherwise
+    """
+
+    for val in result["account_objects"]:
+        if (
+            val["Issuer"] == issuer
+            and val["Subject"] == subject
+            and val["CredentialType"] == cred_type
+        ):
+            return True
+
+    return False
+
+
+class TestCredentials(IntegrationTestCase):
+    @test_async_and_sync(globals())
+    async def test_valid(self, client):
+        # Define entities helpful for Credential lifecycle
+        _ISSUER = WALLET.address
+        _SUBJECT = DESTINATION.address
+
+        # Disambiguate the sync/async, json/websocket tests with different
+        # credential type values -- this avoids tecDUPLICATE error
+        # self.value is defined inside the above decorator
+        cred_type = str_to_hex("Passport_" + str(self.value))
+
+        tx = CredentialCreate(
+            account=_ISSUER,
+            subject=_SUBJECT,
+            credential_type=cred_type,
+            uri=str_to_hex(_URI),
+        )
+        response = await sign_and_reliable_submission_async(tx, WALLET, client)
+        self.assertEqual(response.status, ResponseStatus.SUCCESS)
+        self.assertEqual(response.result["engine_result"], "tesSUCCESS")
+
+        # Use the LedgerEntry RPC to validate the creation of the credential object
+        ledger_entry_response = await client.request(
+            LedgerEntry(
+                credential=Credential(
+                    subject=_SUBJECT, issuer=_ISSUER, credential_type=cred_type
+                )
+            )
+        )
+
+        self.assertEqual(ledger_entry_response.status, ResponseStatus.SUCCESS)
+
+        # Execute the CredentialAccept transaction on the above Credential ledger object
+        tx = CredentialAccept(
+            issuer=_ISSUER, account=_SUBJECT, credential_type=cred_type
+        )
+        # CredentialAccept transaction is submitted by SUBJECT
+        response = await sign_and_reliable_submission_async(tx, DESTINATION, client)
+        self.assertEqual(response.status, ResponseStatus.SUCCESS)
+        self.assertEqual(response.result["engine_result"], "tesSUCCESS")
+
+        # Execute the CredentialDelete transaction
+        # Subject initiates the deletion of the Credential ledger object
+        tx = CredentialDelete(
+            issuer=_ISSUER, account=_SUBJECT, credential_type=cred_type
+        )
+
+        response = await sign_and_reliable_submission_async(tx, DESTINATION, client)
+        self.assertEqual(response.status, ResponseStatus.SUCCESS)
+        self.assertEqual(response.result["engine_result"], "tesSUCCESS")
+
+        # The credential ledger object must be deleted from both the Issuer and Subject
+        # account's directory pages
+        account_objects_response = await client.request(
+            AccountObjects(account=_ISSUER, type=LedgerEntryType.CREDENTIAL)
+        )
+        self.assertFalse(
+            is_cred_object_present(
+                account_objects_response.result,
+                issuer=_ISSUER,
+                subject=_SUBJECT,
+                cred_type=cred_type,
+            )
+        )
+
+        # Verify that the Credential object has been deleted from the Subject's
+        # directory page as well
+        account_objects_response = await client.request(
+            AccountObjects(account=_SUBJECT, type=LedgerEntryType.CREDENTIAL)
+        )
+        self.assertFalse(
+            is_cred_object_present(
+                account_objects_response.result,
+                issuer=_ISSUER,
+                subject=_SUBJECT,
+                cred_type=cred_type,
+            )
+        )

tests/integration/transactions/test_delete_oracle.py

@@ -6,7 +6,7 @@
     test_async_and_sync,
 )
 from tests.integration.reusable_values import WALLET
-from xrpl.models import AccountObjects, AccountObjectType, OracleDelete, OracleSet
+from xrpl.models import AccountObjects, LedgerEntryType, OracleDelete, OracleSet
 from xrpl.models.response import ResponseStatus
 from xrpl.models.transactions.oracle_set import PriceData
 from xrpl.utils import str_to_hex
@@ -54,6 +54,6 @@ async def test_basic(self, client):
 
         # confirm that the PriceOracle was actually deleted
         account_objects_response = await client.request(
-            AccountObjects(account=WALLET.address, type=AccountObjectType.ORACLE)
+            AccountObjects(account=WALLET.address, type=LedgerEntryType.ORACLE)
         )
         self.assertEqual(len(account_objects_response.result["account_objects"]), 0)

tests/integration/transactions/test_deposit_preauth.py

@@ -3,33 +3,65 @@
     sign_and_reliable_submission_async,
     test_async_and_sync,
 )
-from tests.integration.reusable_values import WALLET
+from tests.integration.reusable_values import DESTINATION, WALLET
 from xrpl.models.response import ResponseStatus
 from xrpl.models.transactions import DepositPreauth
+from xrpl.models.transactions.deposit_preauth import Credential
+from xrpl.utils import str_to_hex
 
 ACCOUNT = WALLET.address
-ADDRESS = "rEhxGqkqPPSxQ3P25J66ft5TwpzV14k2de"
 
 
 class TestDepositPreauth(IntegrationTestCase):
     @test_async_and_sync(globals())
-    async def test_authorize(self, client):
+    async def test_authorize_unauthorize_fields(self, client):
         deposit_preauth = DepositPreauth(
             account=ACCOUNT,
-            authorize=ADDRESS,
+            authorize=DESTINATION.address,
         )
         response = await sign_and_reliable_submission_async(
             deposit_preauth, WALLET, client
         )
         self.assertEqual(response.status, ResponseStatus.SUCCESS)
+        self.assertEqual(response.result["engine_result"], "tesSUCCESS")
+
+        # validate the un-authorization of the same address as above
+        deposit_preauth = DepositPreauth(
+            account=ACCOUNT,
+            unauthorize=DESTINATION.address,
+        )
+        response = await sign_and_reliable_submission_async(
+            deposit_preauth, WALLET, client
+        )
+        self.assertEqual(response.status, ResponseStatus.SUCCESS)
+        self.assertEqual(response.result["engine_result"], "tesSUCCESS")
 
     @test_async_and_sync(globals())
-    async def test_unauthorize(self, client):
+    async def test_credentials_array_input_fields(self, client):
+        sample_credentials = [
+            Credential(
+                issuer=DESTINATION.address, credential_type=str_to_hex("SampleCredType")
+            )
+        ]
+
+        # Test the authorize_credentials input field
+        deposit_preauth = DepositPreauth(
+            account=ACCOUNT,
+            authorize_credentials=sample_credentials,
+        )
+        response = await sign_and_reliable_submission_async(
+            deposit_preauth, WALLET, client
+        )
+        self.assertEqual(response.status, ResponseStatus.SUCCESS)
+        self.assertEqual(response.result["engine_result"], "tesSUCCESS")
+
+        # Test the unauthorize_credentials input field
         deposit_preauth = DepositPreauth(
             account=ACCOUNT,
-            unauthorize=ADDRESS,
+            unauthorize_credentials=sample_credentials,
         )
         response = await sign_and_reliable_submission_async(
             deposit_preauth, WALLET, client
         )
         self.assertEqual(response.status, ResponseStatus.SUCCESS)
+        self.assertEqual(response.result["engine_result"], "tesSUCCESS")

tests/integration/transactions/test_did_delete.py

@@ -4,7 +4,7 @@
     test_async_and_sync,
 )
 from tests.integration.reusable_values import WALLET
-from xrpl.models import AccountObjects, AccountObjectType, DIDDelete, DIDSet
+from xrpl.models import AccountObjects, DIDDelete, DIDSet, LedgerEntryType
 from xrpl.models.response import ResponseStatus
 
 _VALID_FIELD = "1234567890abcdefABCDEF"
@@ -26,7 +26,7 @@ async def test_basic(self, client):
 
         # confirm that the DID was actually created
         account_objects_response = await client.request(
-            AccountObjects(account=WALLET.address, type=AccountObjectType.DID)
+            AccountObjects(account=WALLET.address, type=LedgerEntryType.DID)
         )
         self.assertEqual(len(account_objects_response.result["account_objects"]), 1)
 
@@ -40,6 +40,6 @@ async def test_basic(self, client):
 
         # confirm that the DID was actually deleted
         account_objects_response = await client.request(
-            AccountObjects(account=WALLET.address, type=AccountObjectType.DID)
+            AccountObjects(account=WALLET.address, type=LedgerEntryType.DID)
         )
         self.assertEqual(len(account_objects_response.result["account_objects"]), 0)