Verifiable Credentials

.ci-config/rippled.cfg

@@ -182,3 +182,5 @@ PriceOracle
 fixEmptyDID
 fixXChainRewardRounding
 fixPreviousTxnID
+# Explicitly enable featureCredentials
+Credentials

tests/integration/transactions/test_credential.py

@@ -0,0 +1,55 @@
+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.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"
+
+
+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")
+
+        # 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")

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/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. '}",
+        )

tests/unit/models/transactions/test_credential_create.py

@@ -0,0 +1,114 @@
+from unittest import TestCase
+
+from xrpl.models.exceptions import XRPLModelException
+from xrpl.models.transactions.credential_create import CredentialCreate
+from xrpl.utils import str_to_hex
+
+_ACCOUNT_ISSUER = "r9LqNeG6qHxjeUocjvVki2XR35weJ9mZgQ"
+_ACCOUNT_SUBJECT = "rNdY9XDnQ4Dr1EgefwU3CBRuAjt3sAutGg"
+_VALID_CREDENTIAL_TYPE = str_to_hex("Passport")
+_VALID_URI = str_to_hex("www.my-id.com/username")
+
+
+class TestCredentialCreate(TestCase):
+    def test_valid(self):
+        tx = CredentialCreate(
+            account=_ACCOUNT_ISSUER,
+            subject=_ACCOUNT_SUBJECT,
+            credential_type=_VALID_CREDENTIAL_TYPE,
+            uri=_VALID_URI,
+        )
+        self.assertTrue(tx.is_valid())
+
+    # invalid URI field inputs
+    def test_uri_field_too_long(self):
+        with self.assertRaises(XRPLModelException) as error:
+            CredentialCreate(
+                account=_ACCOUNT_ISSUER,
+                subject=_ACCOUNT_SUBJECT,
+                credential_type=_VALID_CREDENTIAL_TYPE,
+                uri=str_to_hex("A" * 257),
+            )
+        self.assertEqual(
+            error.exception.args[0],
+            "{'uri': 'Length of URI field must not be greater than 256 characters. '}",
+        )
+
+    def test_uri_field_empty(self):
+        with self.assertRaises(XRPLModelException) as error:
+            CredentialCreate(
+                account=_ACCOUNT_ISSUER,
+                subject=_ACCOUNT_SUBJECT,
+                credential_type=_VALID_CREDENTIAL_TYPE,
+                uri=str_to_hex(""),
+            )
+        self.assertEqual(
+            error.exception.args[0],
+            "{'uri': 'Length of URI field must be greater than 0. URI field must be "
+            + "encoded in base-16 format. '}",
+        )
+
+    def test_uri_field_not_hex(self):
+        with self.assertRaises(XRPLModelException) as error:
+            CredentialCreate(
+                account=_ACCOUNT_ISSUER,
+                subject=_ACCOUNT_SUBJECT,
+                credential_type=_VALID_CREDENTIAL_TYPE,
+                uri="www.identity-repo.com/username",
+            )
+        self.assertEqual(
+            error.exception.args[0],
+            "{'uri': 'URI field must be encoded in base-16 format. '}",
+        )
+
+    # invalid inputs to the credential_type field
+    def test_cred_type_field_too_long(self):
+        with self.assertRaises(XRPLModelException) as error:
+            CredentialCreate(
+                account=_ACCOUNT_ISSUER,
+                subject=_ACCOUNT_SUBJECT,
+                credential_type=str_to_hex("A" * 65),
+                uri=_VALID_URI,
+            )
+        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:
+            CredentialCreate(
+                account=_ACCOUNT_ISSUER,
+                subject=_ACCOUNT_SUBJECT,
+                credential_type="",
+                uri=_VALID_URI,
+            )
+        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:
+            CredentialCreate(
+                account=_ACCOUNT_ISSUER,
+                subject=_ACCOUNT_SUBJECT,
+                credential_type="Passport",
+                uri=_VALID_URI,
+            )
+        self.assertEqual(
+            error.exception.args[0],
+            "{'credential_type': 'credential_type field must be encoded in base-16 "
+            + "format. '}",
+        )
+
+    def test_create_cred_type_object_all_empty_fields(self):
+        with self.assertRaises(XRPLModelException):
+            CredentialCreate(
+                account=_ACCOUNT_ISSUER,
+                subject=_ACCOUNT_SUBJECT,
+                credential_type="",
+                uri="",
+            )

tests/unit/models/transactions/test_credential_delete.py

@@ -0,0 +1,79 @@
+from unittest import TestCase
+
+from xrpl.models.exceptions import XRPLModelException
+from xrpl.models.transactions.credential_delete import CredentialDelete
+from xrpl.utils import str_to_hex
+
+_ACCOUNT_ISSUER = "r9LqNeG6qHxjeUocjvVki2XR35weJ9mZgQ"
+_ACCOUNT_SUBJECT = "rNdY9XDnQ4Dr1EgefwU3CBRuAjt3sAutGg"
+_VALID_CREDENTIAL_TYPE = str_to_hex("Passport")
+
+
+class TestCredentialDelete(TestCase):
+    def test_valid(self):
+        tx = CredentialDelete(
+            issuer=_ACCOUNT_ISSUER,
+            account=_ACCOUNT_SUBJECT,
+            credential_type=_VALID_CREDENTIAL_TYPE,
+        )
+        self.assertTrue(tx.is_valid())
+
+        # alternative specification of the CredentialDelete transaction
+        tx = CredentialDelete(
+            account=_ACCOUNT_ISSUER,
+            subject=_ACCOUNT_SUBJECT,
+            credential_type=_VALID_CREDENTIAL_TYPE,
+        )
+        self.assertTrue(tx.is_valid())
+
+    def test_unspecified_subject_and_issuer(self):
+        with self.assertRaises(XRPLModelException) as error:
+            CredentialDelete(
+                account=_ACCOUNT_SUBJECT,
+                credential_type=str_to_hex("DMV_ID"),
+            )
+        self.assertEqual(
+            error.exception.args[0],
+            "{'invalid_params': 'CredentialDelete transaction requires at least one "
+            + "input amongst issuer or subject. '}",
+        )
+
+    # invalid inputs to the credential_type field
+    def test_cred_type_field_too_long(self):
+        with self.assertRaises(XRPLModelException) as error:
+            CredentialDelete(
+                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:
+            CredentialDelete(
+                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:
+            CredentialDelete(
+                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. '}",
+        )