Add support for endorser write author DID

Signed-off-by: Ian Costanzo <ian@anon-solutions.ca>

Author: ianco

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

aries_cloudagent/protocols/endorse_transaction/v1_0/manager.py

@@ -118,6 +118,8 @@ async def create_request(
         signed_request: dict = None,
         expires_time: str = None,
         endorser_write_txn: bool = None,
+        author_goal_code: str = None,
+        signer_goal_code: str = None,
     ):
         """
         Create a new Transaction Request.
@@ -142,8 +144,12 @@ async def create_request(
             "context": TransactionRecord.SIGNATURE_CONTEXT,
             "method": TransactionRecord.ADD_SIGNATURE,
             "signature_type": TransactionRecord.SIGNATURE_TYPE,
-            "signer_goal_code": TransactionRecord.ENDORSE_TRANSACTION,
-            "author_goal_code": TransactionRecord.WRITE_TRANSACTION,
+            "signer_goal_code": signer_goal_code
+            if signer_goal_code
+            else TransactionRecord.ENDORSE_TRANSACTION,
+            "author_goal_code": author_goal_code
+            if author_goal_code
+            else TransactionRecord.WRITE_TRANSACTION,
         }
         transaction.signature_request.clear()
         transaction.signature_request.append(signature_request)
@@ -233,6 +239,7 @@ async def create_endorse_response(
 
         transaction._type = TransactionRecord.SIGNATURE_RESPONSE
         transaction_json = transaction.messages_attach[0]["data"]["json"]
+        ledger_response = {}
 
         async with self._profile.session() as session:
             wallet: BaseWallet = session.inject_or(BaseWallet)
@@ -266,9 +273,40 @@ async def create_endorse_response(
             raise LedgerError(reason=reason)
 
         async with ledger:
-            endorsed_msg = await shield(
-                ledger.txn_endorse(transaction_json, endorse_did=endorser_did_info)
+            # check our goal code!
+            txn_goal_code = (
+                transaction.signature_request[0]["signer_goal_code"]
+                if transaction.signature_request
+                and "signer_goal_code" in transaction.signature_request[0]
+                else TransactionRecord.ENDORSE_TRANSACTION
             )
+            if txn_goal_code == TransactionRecord.ENDORSE_TRANSACTION:
+                endorsed_msg = await shield(
+                    ledger.txn_endorse(transaction_json, endorse_did=endorser_did_info)
+                )
+            elif txn_goal_code == TransactionRecord.WRITE_DID_TRANSACTION:
+                # get DID info from transaction.meta_data
+                meta_data = json.loads(transaction_json)
+                (success, txn) = await shield(
+                    ledger.register_nym(
+                        meta_data["did"],
+                        meta_data["verkey"],
+                        meta_data["alias"],
+                        meta_data["role"],
+                    )
+                )
+                # we don't have an endorsed transaction so just return did meta-data
+                ledger_response = {
+                    "result": {
+                        "txn": {"type": "1", "data": {"dest": meta_data["did"]}}
+                    },
+                    "meta_data": meta_data,
+                }
+                endorsed_msg = json.dumps(ledger_response)
+            else:
+                raise TransactionManagerError(
+                    f"Invalid goal code for transaction record:" f" {txn_goal_code}"
+                )
 
         # need to return the endorsed msg or else the ledger will reject the
         # eventual transaction write
@@ -278,7 +316,7 @@ async def create_endorse_response(
             "message_id": transaction.messages_attach[0]["@id"],
             "context": TransactionRecord.SIGNATURE_CONTEXT,
             "method": TransactionRecord.ADD_SIGNATURE,
-            "signer_goal_code": TransactionRecord.ENDORSE_TRANSACTION,
+            "signer_goal_code": txn_goal_code,
             "signature_type": TransactionRecord.SIGNATURE_TYPE,
             "signature": {endorser_did: endorsed_msg or endorser_verkey},
         }
@@ -291,8 +329,12 @@ async def create_endorse_response(
         async with self._profile.session() as session:
             await transaction.save(session, reason="Created an endorsed response")
 
-        if transaction.endorser_write_txn:
-            ledger_response = await self.complete_transaction(transaction)
+        if (
+            transaction.endorser_write_txn
+            and txn_goal_code == TransactionRecord.ENDORSE_TRANSACTION
+        ):
+            # running as the endorser, we've been asked to write the transaction
+            ledger_response = await self.complete_transaction(transaction, True)
             endorsed_transaction_response = EndorsedTransactionResponse(
                 transaction_id=transaction.thread_id,
                 thread_id=transaction._id,
@@ -310,6 +352,7 @@ async def create_endorse_response(
             signature_response=signature_response,
             state=state,
             endorser_did=endorser_did,
+            ledger_response=ledger_response,
         )
 
         return transaction, endorsed_transaction_response
@@ -357,7 +400,9 @@ async def receive_endorse_response(self, response: EndorsedTransactionResponse):
 
         return transaction
 
-    async def complete_transaction(self, transaction: TransactionRecord):
+    async def complete_transaction(
+        self, transaction: TransactionRecord, endorser: bool = False
+    ):
         """
         Complete a transaction.
 
@@ -371,24 +416,34 @@ async def complete_transaction(self, transaction: TransactionRecord):
             The updated transaction
 
         """
+
         ledger_transaction = transaction.messages_attach[0]["data"]["json"]
 
-        ledger = self._profile.inject(BaseLedger)
-        if not ledger:
-            reason = "No ledger available"
-            if not self._profile.context.settings.get_value("wallet.type"):
-                reason += ": missing wallet-type?"
-            raise TransactionManagerError(reason)
+        # check if we (author) have requested the endorser to write the transaction
+        if (endorser and transaction.endorser_write_txn) or (
+            (not endorser) and (not transaction.endorser_write_txn)
+        ):
+            ledger = self._profile.inject(BaseLedger)
+            if not ledger:
+                reason = "No ledger available"
+                if not self._profile.context.settings.get_value("wallet.type"):
+                    reason += ": missing wallet-type?"
+                raise TransactionManagerError(reason)
 
-        async with ledger:
-            try:
-                ledger_response_json = await shield(
-                    ledger.txn_submit(ledger_transaction, sign=False, taa_accept=False)
-                )
-            except (IndyIssuerError, LedgerError) as err:
-                raise TransactionManagerError(err.roll_up) from err
+            async with ledger:
+                try:
+                    ledger_response_json = await shield(
+                        ledger.txn_submit(
+                            ledger_transaction, sign=False, taa_accept=False
+                        )
+                    )
+                except (IndyIssuerError, LedgerError) as err:
+                    raise TransactionManagerError(err.roll_up) from err
+
+            ledger_response = json.loads(ledger_response_json)
 
-        ledger_response = json.loads(ledger_response_json)
+        else:
+            ledger_response = ledger_transaction
 
         transaction.state = TransactionRecord.STATE_TRANSACTION_ACKED
 
@@ -397,7 +452,7 @@ async def complete_transaction(self, transaction: TransactionRecord):
 
         # this scenario is where the endorser is writing the transaction
         # (called from self.create_endorse_response())
-        if transaction.endorser_write_txn:
+        if endorser and transaction.endorser_write_txn:
             return ledger_response
 
         connection_id = transaction.connection_id
@@ -733,6 +788,9 @@ async def endorsed_txn_post_processing(
                          would be stored in wallet.
         """
 
+        if isinstance(ledger_response, str):
+            ledger_response = json.loads(ledger_response)
+
         ledger = self._profile.inject(BaseLedger)
         if not ledger:
             reason = "No ledger available"

aries_cloudagent/protocols/endorse_transaction/v1_0/models/transaction_record.py

@@ -9,7 +9,13 @@
 )
 from .....messaging.valid import UUIDFour
 
-from ..controller import ENDORSE_TRANSACTION, REFUSE_TRANSACTION, WRITE_TRANSACTION
+from ..controller import (
+    ENDORSE_TRANSACTION,
+    REFUSE_TRANSACTION,
+    WRITE_TRANSACTION,
+    WRITE_DID_TRANSACTION,
+    REGISTER_PUBLIC_DID,
+)
 
 
 class TransactionRecord(BaseExchangeRecord):
@@ -40,6 +46,8 @@ class Meta:
     ENDORSE_TRANSACTION = ENDORSE_TRANSACTION
     REFUSE_TRANSACTION = REFUSE_TRANSACTION
     WRITE_TRANSACTION = WRITE_TRANSACTION
+    WRITE_DID_TRANSACTION = WRITE_DID_TRANSACTION
+    REGISTER_PUBLIC_DID = REGISTER_PUBLIC_DID
 
     FORMAT_VERSION = "dif/endorse-transaction/request@v1.0"
 

aries_cloudagent/protocols/endorse_transaction/v1_0/routes.py

@@ -710,7 +710,7 @@ async def transaction_write(request: web.BaseRequest):
         (
             tx_completed,
             transaction_acknowledgement_message,
-        ) = await transaction_mgr.complete_transaction(transaction=transaction)
+        ) = await transaction_mgr.complete_transaction(transaction, False)
     except StorageError as err:
         raise web.HTTPBadRequest(reason=err.roll_up) from err
 

aries_cloudagent/protocols/endorse_transaction/v1_0/tests/test_manager.py

@@ -427,7 +427,7 @@ async def test_complete_transaction(self):
             (
                 transaction_record,
                 transaction_acknowledgement_message,
-            ) = await self.manager.complete_transaction(transaction_record)
+            ) = await self.manager.complete_transaction(transaction_record, False)
             save_record.assert_called_once()
 
         assert transaction_record.state == TransactionRecord.STATE_TRANSACTION_ACKED