Verifiable Credentials

.ci-config/rippled.cfg

@@ -182,3 +182,5 @@ PriceOracle
 fixEmptyDID
 fixXChainRewardRounding
 fixPreviousTxnID
+fixAMMv1_1
+Credentials

tests/integration/transactions/test_credential.py

@@ -0,0 +1,108 @@
+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, AccountObjectType
+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, issuer, subject, cred_type) -> bool:
+    """
+    Utility method that checks if the specified JSON contains the Credential ledger
+    object. The result JSON must be the output of account_objects RPC command.
+
+    Returns True, if the input JSON contains the Credential Ledger object
+    Returns 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 TestCredentialCreate(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")
+
+        # Note: If it isn't too cluttered, verification tests pertaining to the
+        # existence of Credential ledger object on the Issuer's and Subject's directory
+        # pages can be included here
+
+        # 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=AccountObjectType.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=AccountObjectType.CREDENTIAL)
+        )
+        self.assertFalse(
+            is_cred_object_present(
+                account_objects_response.result,
+                issuer=_ISSUER,
+                subject=_SUBJECT,
+                cred_type=cred_type,
+            )
+        )

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/unit/models/requests/test_deposit_authorized.py

@@ -0,0 +1,15 @@
+from unittest import TestCase
+
+from xrpl.models import DepositAuthorized
+
+
+class TestDepositAuthorized(TestCase):
+    def test_valid(self):
+        req = DepositAuthorized(
+            source_account="srcAccount",
+            destination_account="dstAccount",
+            credentials=[
+                "EA85602C1B41F6F1F5E83C0E6B87142FB8957BD209469E4CC347BA2D0C26F66A"
+            ],
+        )
+        self.assertTrue(req.is_valid())

tests/unit/models/transactions/test_account_delete.py

@@ -0,0 +1,45 @@
+from unittest import TestCase
+
+from xrpl.models.exceptions import XRPLModelException
+from xrpl.models.transactions import AccountDelete
+
+_ACCOUNT = "r9LqNeG6qHxjeUocjvVki2XR35weJ9mZgQ"
+_DESTINATION = "rf7HPydP4ihkFkSRHWFq34b4SXRc7GvPCR"
+
+
+class TestAccountDelete(TestCase):
+    def test_creds_list_too_long(self):
+        with self.assertRaises(XRPLModelException) as err:
+            AccountDelete(
+                account=_ACCOUNT,
+                destination=_DESTINATION,
+                credential_ids=["credential_index_" + str(i) for i in range(9)],
+            )
+
+        self.assertEqual(
+            err.exception.args[0],
+            "{'credential_ids': 'CredentialIDs list cannot have more than 8 "
+            + "elements.'}",
+        )
+
+    def test_creds_list_empty(self):
+        with self.assertRaises(XRPLModelException) as err:
+            AccountDelete(
+                account=_ACCOUNT,
+                destination=_DESTINATION,
+                credential_ids=[],
+            )
+        self.assertEqual(
+            err.exception.args[0],
+            "{'credential_ids': 'CredentialIDs list cannot be empty.'}",
+        )
+
+    def test_valid_account_delete_txn(self):
+        tx = AccountDelete(
+            account=_ACCOUNT,
+            destination=_DESTINATION,
+            credential_ids=[
+                "EA85602C1B41F6F1F5E83C0E6B87142FB8957BD209469E4CC347BA2D0C26F66A"
+            ],
+        )
+        self.assertTrue(tx.is_valid())

tests/unit/models/transactions/test_credential_accept.py

@@ -0,0 +1,59 @@
+from unittest import TestCase
+
+from xrpl.models.exceptions import XRPLModelException
+from xrpl.models.transactions.credential_accept import CredentialAccept
+from xrpl.utils import str_to_hex
+
+_ACCOUNT_ISSUER = "r9LqNeG6qHxjeUocjvVki2XR35weJ9mZgQ"
+_ACCOUNT_SUBJECT = "rNdY9XDnQ4Dr1EgefwU3CBRuAjt3sAutGg"
+_VALID_CREDENTIAL_TYPE = str_to_hex("Passport")
+
+
+class TestCredentialAccept(TestCase):
+    def test_valid(self):
+        tx = CredentialAccept(
+            issuer=_ACCOUNT_ISSUER,
+            account=_ACCOUNT_SUBJECT,
+            credential_type=_VALID_CREDENTIAL_TYPE,
+        )
+        self.assertTrue(tx.is_valid())
+
+    # invalid inputs to the credential_type field
+    def test_cred_type_field_too_long(self):
+        with self.assertRaises(XRPLModelException) as error:
+            CredentialAccept(
+                issuer=_ACCOUNT_ISSUER,
+                account=_ACCOUNT_SUBJECT,
+                credential_type=str_to_hex("A" * 65),
+            )
+        self.assertEqual(
+            error.exception.args[0],
+            "{'credential_type': 'Length of credential_type field must not be greater "
+            + "than 64 bytes. '}",
+        )
+
+    def test_cred_type_field_empty(self):
+        with self.assertRaises(XRPLModelException) as error:
+            CredentialAccept(
+                issuer=_ACCOUNT_ISSUER,
+                account=_ACCOUNT_SUBJECT,
+                credential_type="",
+            )
+        self.assertEqual(
+            error.exception.args[0],
+            "{'credential_type': 'Length of credential_type field must be greater than "
+            + "0. credential_type field must be encoded in base-16 format. '}",
+        )
+
+    def test_cred_type_field_not_hex(self):
+        with self.assertRaises(XRPLModelException) as error:
+            CredentialAccept(
+                issuer=_ACCOUNT_ISSUER,
+                account=_ACCOUNT_SUBJECT,
+                credential_type="Passport",
+            )
+        self.assertEqual(
+            error.exception.args[0],
+            "{'credential_type': 'credential_type field must be encoded in base-16 "
+            + "format. '}",
+        )