Merge branch 'hyperledger:main' into feature/did-method-key-type-registry

Author: burdettadam

Endorser.md

@@ -56,7 +56,7 @@ Endorsement:
                         For Authors, specify whether to automatically create transactions for a cred def's revocation registry. (If not specified, the controller must invoke the endpoints required to create
                         the revocation registry and assign to the cred def.) [env var: ACAPY_CREATE_REVOCATION_TRANSACTIONS]
   --auto-promote-author-did
-                        For Authors, specify whether to automatically promote a DID to the wallet public DID after writing to the ledger.
+                        For Authors, specify whether to automatically promote a DID to the wallet public DID after writing to the ledger. [env var: ACAPY_AUTO_PROMOTE_AUTHOR_DID]
 ```
 
 ## How Aca-py Handles Endorsements

aries_cloudagent/config/argparse.py

@@ -1837,7 +1837,7 @@ def add_arguments(self, parser: ArgumentParser):
         parser.add_argument(
             "--auto-promote-author-did",
             action="store_true",
-            env_var="ACAPY_PROMOTE-AUTHOR-DID",
+            env_var="ACAPY_AUTO_PROMOTE_AUTHOR_DID",
             help="For Authors, specify whether to automatically promote"
             " a DID to the wallet public DID after writing to the ledger.",
         )

aries_cloudagent/core/conductor.py

@@ -450,8 +450,7 @@ async def start(self) -> None:
                         if mediation_connections_invite
                         else OutOfBandManager(self.root_profile)
                     )
-
-                    conn_record = await mgr.receive_invitation(
+                    record = await mgr.receive_invitation(
                         invitation=invitation_handler.from_url(
                             mediation_invite_record.invite
                         ),
@@ -464,10 +463,10 @@ async def start(self) -> None:
                             ).mark_default_invite_as_used()
                         )
 
-                        await conn_record.metadata_set(
+                        await record.metadata_set(
                             session, MediationManager.SEND_REQ_AFTER_CONNECTION, True
                         )
-                        await conn_record.metadata_set(
+                        await record.metadata_set(
                             session, MediationManager.SET_TO_DEFAULT_ON_GRANTED, True
                         )
 

aries_cloudagent/core/dispatcher.py

@@ -296,10 +296,10 @@ async def make_message(
         if not isinstance(parsed_msg, dict):
             raise MessageParseError("Expected a JSON object")
         message_type = parsed_msg.get("@type")
-        message_type_rec_version = get_version_from_message_type(message_type)
 
         if not message_type:
             raise MessageParseError("Message does not contain '@type' parameter")
+        message_type_rec_version = get_version_from_message_type(message_type)
 
         registry: ProtocolRegistry = self.profile.inject(ProtocolRegistry)
         try:

aries_cloudagent/core/tests/test_conductor.py

@@ -21,6 +21,7 @@
 from ...protocols.coordinate_mediation.v1_0.models.mediation_record import (
     MediationRecord,
 )
+from ...protocols.out_of_band.v1_0.models.oob_record import OobRecord
 from ...resolver.did_resolver import DIDResolver
 from ...storage.base import BaseStorage
 from ...storage.error import StorageNotFoundError
@@ -1155,7 +1156,9 @@ async def test_mediator_invitation_0434(self, mock_from_url, _):
                 "test": async_mock.MagicMock(schemes=["http"])
             }
             await conductor.setup()
-
+        conductor.root_profile.context.update_settings(
+            {"mediation.connections_invite": False}
+        )
         conn_record = ConnRecord(
             invitation_key="3Dn1SJNPaCXcvvJvSbsFWP2xaCjMom3can8CQNhWrTRx",
             their_label="Hello",
@@ -1164,12 +1167,20 @@ async def test_mediator_invitation_0434(self, mock_from_url, _):
         )
         conn_record.accept = ConnRecord.ACCEPT_MANUAL
         await conn_record.save(await conductor.root_profile.session())
+        invitation = test_module.InvitationMessage()
+        oob_record = OobRecord(
+            invitation=invitation,
+            invi_msg_id=invitation._id,
+            role=OobRecord.ROLE_RECEIVER,
+            connection_id=conn_record.connection_id,
+            state=OobRecord.STATE_INITIAL,
+        )
         with async_mock.patch.object(
             test_module,
             "OutOfBandManager",
             async_mock.MagicMock(
                 return_value=async_mock.MagicMock(
-                    receive_invitation=async_mock.AsyncMock(return_value=conn_record)
+                    receive_invitation=async_mock.AsyncMock(return_value=oob_record)
                 )
             ),
         ) as mock_mgr, async_mock.patch.object(
@@ -1179,6 +1190,7 @@ async def test_mediator_invitation_0434(self, mock_from_url, _):
                 return_value=async_mock.MagicMock(value=f"v{__version__}")
             ),
         ):
+            assert not conductor.root_profile.settings["mediation.connections_invite"]
             await conductor.start()
             await conductor.stop()
             mock_from_url.assert_called_once_with("test-invite")

aries_cloudagent/ledger/routes.py

@@ -26,6 +26,7 @@
     TransactionManagerError,
 )
 from ..protocols.endorse_transaction.v1_0.models.transaction_record import (
+    TransactionRecord,
     TransactionRecordSchema,
 )
 from ..protocols.endorse_transaction.v1_0.util import (
@@ -295,18 +296,29 @@ async def register_ledger_nym(request: web.BaseRequest):
             )
         endorser_did = endorser_info["endorser_did"]
 
+    meta_data = {"did": did, "verkey": verkey, "alias": alias, "role": role}
     success = False
     txn = None
     async with ledger:
         try:
-            (success, txn) = await ledger.register_nym(
-                did,
-                verkey,
-                alias,
-                role,
-                write_ledger=write_ledger,
-                endorser_did=endorser_did,
-            )
+            # if we are an author check if we have a public DID or not
+            write_ledger_nym_transaction = True
+            # special case - if we are an author with no public DID
+            if create_transaction_for_endorser:
+                public_info = await ledger.get_wallet_public_did()
+                if not public_info:
+                    write_ledger_nym_transaction = False
+                    success = False
+                    txn = {"signed_txn": json.dumps(meta_data)}
+            if write_ledger_nym_transaction:
+                (success, txn) = await ledger.register_nym(
+                    did,
+                    verkey,
+                    alias,
+                    role,
+                    write_ledger=write_ledger,
+                    endorser_did=endorser_did,
+                )
         except LedgerTransactionError as err:
             raise web.HTTPForbidden(reason=err.roll_up)
         except LedgerError as err:
@@ -321,7 +333,6 @@ async def register_ledger_nym(request: web.BaseRequest):
                 )
             )
 
-    meta_data = {"did": did, "verkey": verkey, "alias": alias, "role": role}
     if not create_transaction_for_endorser:
         # Notify event
         await notify_register_did_event(context.profile, did, meta_data)
@@ -340,12 +351,21 @@ async def register_ledger_nym(request: web.BaseRequest):
         # if auto-request, send the request to the endorser
         if context.settings.get_value("endorser.auto_request"):
             try:
+                endorser_write_txn = not write_ledger_nym_transaction
                 transaction, transaction_request = await transaction_mgr.create_request(
                     transaction=transaction,
+                    author_goal_code=TransactionRecord.REGISTER_PUBLIC_DID
+                    if endorser_write_txn
+                    else None,
+                    signer_goal_code=TransactionRecord.WRITE_DID_TRANSACTION
+                    if endorser_write_txn
+                    else None,
+                    endorser_write_txn=endorser_write_txn,
                     # TODO see if we need to parameterize these params
                     # expires_time=expires_time,
                     # endorser_write_txn=endorser_write_txn,
                 )
+                txn = transaction.serialize()
             except (StorageError, TransactionManagerError) as err:
                 raise web.HTTPBadRequest(reason=err.roll_up) from err
 

aries_cloudagent/ledger/tests/test_routes.py

@@ -359,6 +359,50 @@ async def test_register_nym_create_transaction_for_endorser(self):
                 {"success": True, "txn": {"signed_txn": {"...": "..."}}}
             )
 
+    async def test_register_nym_create_transaction_for_endorser_no_public_did(self):
+        self.request.query = {
+            "did": "a_test_did",
+            "verkey": "a_test_verkey",
+            "alias": "did_alias",
+            "role": "reset",
+            "create_transaction_for_endorser": "true",
+            "conn_id": "dummy",
+        }
+        self.profile.context.settings["endorser.author"] = True
+
+        with async_mock.patch.object(
+            ConnRecord, "retrieve_by_id", async_mock.AsyncMock()
+        ) as mock_conn_rec_retrieve, async_mock.patch.object(
+            test_module, "TransactionManager", async_mock.MagicMock()
+        ) as mock_txn_mgr, async_mock.patch.object(
+            test_module.web, "json_response", async_mock.MagicMock()
+        ) as mock_response:
+            mock_txn_mgr.return_value = async_mock.MagicMock(
+                create_record=async_mock.AsyncMock(
+                    return_value=async_mock.MagicMock(
+                        serialize=async_mock.MagicMock(return_value={"...": "..."})
+                    )
+                )
+            )
+            mock_conn_rec_retrieve.return_value = async_mock.MagicMock(
+                metadata_get=async_mock.AsyncMock(
+                    return_value={
+                        "endorser_did": ("did"),
+                        "endorser_name": ("name"),
+                    }
+                )
+            )
+            self.ledger.register_nym.return_value: Tuple[bool, dict] = (
+                True,
+                {"signed_txn": {"...": "..."}},
+            )
+
+            result = await test_module.register_ledger_nym(self.request)
+            assert result == mock_response.return_value
+            mock_response.assert_called_once_with(
+                {"success": True, "txn": {"signed_txn": {"...": "..."}}}
+            )
+
     async def test_register_nym_create_transaction_for_endorser_storage_x(self):
         self.request.query = {
             "did": "a_test_did",