Merge branch 'main' into feature/enable-aggr-vcs

Author: teanas

aries_cloudagent/core/conductor.py

@@ -26,7 +26,6 @@
 from ..config.logging import LoggingConfigurator
 from ..config.provider import ClassProvider
 from ..config.wallet import wallet_config
-from ..connections.models.conn_record import ConnRecord
 from ..core.profile import Profile
 from ..indy.verifier import IndyVerifier
 from ..ledger.base import BaseLedger
@@ -451,33 +450,23 @@ async def start(self) -> None:
                         if mediation_connections_invite
                         else OutOfBandManager(self.root_profile)
                     )
-                    async with self.root_profile.session() as session:
-                        invitation = invitation_handler.from_url(
+                    record = await mgr.receive_invitation(
+                        invitation=invitation_handler.from_url(
                             mediation_invite_record.invite
-                        )
-                        if isinstance(mgr, OutOfBandManager):
-                            oob_record = await mgr.receive_invitation(
-                                invitation=invitation,
-                                auto_accept=True,
-                            )
-                            conn_record = await ConnRecord.retrieve_by_id(
-                                session, oob_record.connection_id
-                            )
-                        else:
-                            conn_record = await mgr.receive_invitation(
-                                invitation=invitation,
-                                auto_accept=True,
-                            )
+                        ),
+                        auto_accept=True,
+                    )
+                    async with self.root_profile.session() as session:
                         await (
                             MediationInviteStore(
                                 session.context.inject(BaseStorage)
                             ).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/tests/test_conductor.py

@@ -24,6 +24,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 ...multitenant.base import BaseMultitenantManager
 from ...multitenant.manager import MultitenantManager
@@ -1172,8 +1173,13 @@ 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())
-        oob_record = async_mock.MagicMock(
+        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,
@@ -1194,6 +1200,7 @@ async def test_mediator_invitation_0434(self, mock_from_url, _):
             await conductor.start()
             await conductor.stop()
             mock_from_url.assert_called_once_with("test-invite")
+            mock_mgr.return_value.receive_invitation.assert_called_once()
 
     @async_mock.patch.object(test_module, "MediationInviteStore")
     @async_mock.patch.object(test_module.ConnectionInvitation, "from_url")

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",

aries_cloudagent/protocols/endorse_transaction/v1_0/controller.py

@@ -5,6 +5,9 @@
 ENDORSE_TRANSACTION = "aries.transaction.endorse"
 REFUSE_TRANSACTION = "aries.transaction.refuse"
 WRITE_TRANSACTION = "aries.transaction.ledger.write"
+WRITE_TRANSACTION = "aries.transaction.ledger.write"
+WRITE_DID_TRANSACTION = "aries.transaction.ledger.write_did"
+REGISTER_PUBLIC_DID = "aries.transaction.register_public_did"
 
 
 class Controller:
@@ -15,4 +18,10 @@ def __init__(self, protocol: str):
 
     def determine_goal_codes(self) -> Sequence[str]:
         """Return defined goal_codes."""
-        return [ENDORSE_TRANSACTION, REFUSE_TRANSACTION, WRITE_TRANSACTION]
+        return [
+            ENDORSE_TRANSACTION,
+            REFUSE_TRANSACTION,
+            WRITE_TRANSACTION,
+            WRITE_DID_TRANSACTION,
+            REGISTER_PUBLIC_DID,
+        ]

aries_cloudagent/protocols/endorse_transaction/v1_0/handlers/endorsed_transaction_response_handler.py

@@ -45,7 +45,7 @@ async def handle(self, context: RequestContext, responder: BaseResponder):
                 (
                     transaction,
                     transaction_acknowledgement_message,
-                ) = await mgr.complete_transaction(transaction=transaction)
+                ) = await mgr.complete_transaction(transaction, False)
 
                 await responder.send_reply(
                     transaction_acknowledgement_message,