Merge pull request #207 from andrewwhitehead/test-static

Add support for test-suite-specific static connection

Author: andrewwhitehead

aries_cloudagent/conductor.py

@@ -10,6 +10,7 @@
 
 import asyncio
 from collections import OrderedDict
+import hashlib
 import logging
 from typing import Coroutine, Union
 
@@ -188,6 +189,23 @@ async def start(self) -> None:
             self.admin_server,
         )
 
+        # Create a static connection for use by the test-suite
+        if context.settings.get("debug.test_suite_endpoint"):
+            mgr = ConnectionManager(self.context)
+            their_endpoint = context.settings["debug.test_suite_endpoint"]
+            test_conn = await mgr.create_static_connection(
+                my_seed=hashlib.sha256(b"aries-protocol-test-subject").digest(),
+                their_seed=hashlib.sha256(b"aries-protocol-test-suite").digest(),
+                their_endpoint=their_endpoint,
+                their_role="tester",
+                alias="test-suite",
+            )
+            print("Created static connection for test suite")
+            print(" - My DID:", test_conn.my_did)
+            print(" - Their DID:", test_conn.their_did)
+            print(" - Their endpoint:", their_endpoint)
+            print()
+
         # Print an invitation to the terminal
         if context.settings.get("debug.print_invitation"):
             try:

aries_cloudagent/config/argparse.py

@@ -233,6 +233,12 @@ def add_arguments(self, parser: ArgumentParser):
             action="store_true",
             help="Flag specifying the generated invite should be public."
         )
+        parser.add_argument(
+            "--test-suite-endpoint",
+            type=str,
+            metavar="<endpoint>",
+            help="URL endpoint for sending messages to the test suite agent."
+        )
 
         parser.add_argument(
             "--auto-accept-invites",
@@ -318,6 +324,8 @@ def get_settings(self, args: Namespace) -> dict:
             settings["debug.invite_multi_use"] = True
         if args.invite_public:
             settings["debug.invite_public"] = True
+        if args.test_suite_endpoint:
+            settings["debug.test_suite_endpoint"] = args.test_suite_endpoint
 
         if args.auto_respond_credential_proposal:
             settings["debug.auto_respond_credential_proposal"] = True

aries_cloudagent/messaging/connections/manager.py

@@ -13,7 +13,9 @@
 from ...storage.error import StorageError, StorageNotFoundError
 from ...storage.record import StorageRecord
 from ...wallet.base import BaseWallet, DIDInfo
+from ...wallet.crypto import create_keypair, seed_to_did
 from ...wallet.error import WalletNotFoundError
+from ...wallet.util import bytes_to_b58
 
 from ..message_delivery import MessageDelivery
 from ..responder import BaseResponder
@@ -68,7 +70,7 @@ async def create_invitation(
         accept: str = None,
         public: bool = False,
         multi_use: bool = False,
-        alias: str = None
+        alias: str = None,
     ) -> Tuple[ConnectionRecord, ConnectionInvitation]:
         """
         Generate new connection invitation.
@@ -161,7 +163,7 @@ async def create_invitation(
             state=ConnectionRecord.STATE_INVITATION,
             accept=accept,
             invitation_mode=invitation_mode,
-            alias=alias
+            alias=alias,
         )
 
         await connection.save(self.context, reason="Created new invitation")
@@ -217,7 +219,7 @@ async def receive_invitation(
             their_role=their_role,
             state=ConnectionRecord.STATE_INVITATION,
             accept=accept,
-            alias=alias
+            alias=alias,
         )
 
         await connection.save(
@@ -276,8 +278,10 @@ async def create_request(
             connection.my_did = my_info.did
 
         # Create connection request message
+        if not my_endpoint:
+            my_endpoint = self.context.settings.get("default_endpoint")
         did_doc = await self.create_did_document(
-            my_info, connection.inbound_connection_id
+            my_info, connection.inbound_connection_id, my_endpoint
         )
         if not my_label:
             my_label = self.context.settings.get("default_label")
@@ -357,7 +361,7 @@ async def receive_request(
 
                 await new_connection.save(
                     self.context,
-                    reason="Received connection request from multi-use invitation DID"
+                    reason="Received connection request from multi-use invitation DID",
                 )
                 connection = new_connection
 
@@ -461,6 +465,8 @@ async def create_response(
             connection.my_did = my_info.did
 
         # Create connection response message
+        if not my_endpoint:
+            my_endpoint = self.context.settings.get("default_endpoint")
         did_doc = await self.create_did_document(
             my_info, connection.inbound_connection_id, my_endpoint
         )
@@ -565,6 +571,70 @@ async def accept_response(
 
         return connection
 
+    async def create_static_connection(
+        self,
+        my_did: str = None,
+        my_seed: str = None,
+        their_did: str = None,
+        their_seed: str = None,
+        their_verkey: str = None,
+        their_endpoint: str = None,
+        their_role: str = None,
+        alias: str = None,
+    ) -> ConnectionRecord:
+        """
+        Register a new static connection (for use by the test suite).
+
+        Args:
+            my_did: override the DID used in the connection
+            my_seed: provide a seed used to generate our DID and keys
+            their_did: provide the DID used by the other party
+            their_seed: provide a seed used to generate their DID and keys
+            their_verkey: provide the verkey used by the other party
+            their_endpoint: their URL endpoint for routing messages
+            their_role: their role in this connection
+            alias: an alias for this connection record
+
+        Returns:
+            The new `ConnectionRecord` instance
+
+        """
+        wallet: BaseWallet = await self.context.inject(BaseWallet)
+
+        # seed and DID optional
+        my_info = await wallet.create_local_did(my_seed, my_did)
+
+        # must provide their DID and verkey if the seed is not known
+        if (not their_did or not their_verkey) and not their_seed:
+            raise ConnectionManagerError(
+                "Either a verkey or seed must be provided for the other party"
+            )
+        if not their_did:
+            their_did = seed_to_did(their_seed)
+        if not their_verkey:
+            their_verkey_bin, _ = create_keypair(their_seed)
+            their_verkey = bytes_to_b58(their_verkey_bin)
+        their_info = DIDInfo(their_did, their_verkey, {})
+
+        print(their_info, my_info)
+
+        # Create connection record
+        connection = ConnectionRecord(
+            initiator=ConnectionRecord.INITIATOR_SELF,
+            my_did=my_info.did,
+            their_did=their_info.did,
+            their_role=their_role,
+            state=ConnectionRecord.STATE_ACTIVE,
+            alias=alias,
+        )
+        await connection.save(self.context, reason="Created new static connection")
+
+        # Synthesize their DID doc
+        did_doc = await self.create_did_document(their_info, None, their_endpoint)
+        await self.store_did_document(did_doc)
+
+        return connection
+
     async def find_connection(
         self,
         their_did: str,
@@ -675,27 +745,27 @@ async def find_message_connection(
 
     async def create_did_document(
         self,
-        my_info: DIDInfo,
+        did_info: DIDInfo,
         inbound_connection_id: str = None,
-        my_endpoint: str = None,
+        svc_endpoint: str = None,
     ) -> DIDDoc:
         """Create our DID document for a given DID.
 
         Args:
-            my_info: The DID I am using in this connection
-            inbound_connection_id: The inbound routing connection id to use
-            my_endpoint: A custom endpoint for the DID Document
+            did_info: The DID information (DID and verkey) used in the connection
+            inbound_connection_id: The ID of the inbound routing connection to use
+            svc_endpoint: A custom endpoint for the DID Document
 
         Returns:
             The prepared `DIDDoc` instance
 
         """
 
-        did_doc = DIDDoc(did=my_info.did)
-        did_controller = my_info.did
-        did_key = my_info.verkey
+        did_doc = DIDDoc(did=did_info.did)
+        did_controller = did_info.did
+        did_key = did_info.verkey
         pk = PublicKey(
-            my_info.did,
+            did_info.did,
             "1",
             did_key,
             PublicKeyType.ED25519_SIG_2018,
@@ -729,24 +799,23 @@ async def create_did_document(
                         "Routing DIDDoc service has no recipient key(s)"
                     )
                 rk = PublicKey(
-                    my_info.did,
+                    did_info.did,
                     f"routing-{router_idx}",
                     service.recip_keys[0].value,
                     PublicKeyType.ED25519_SIG_2018,
                     did_controller,
                     True,
                 )
                 routing_keys.append(rk)
-                my_endpoint = service.endpoint
+                svc_endpoint = service.endpoint
                 break
             router_id = router.inbound_connection_id
 
-        if not my_endpoint:
-            my_endpoint = self.context.settings.get("default_endpoint")
-        service = Service(
-            my_info.did, "indy", "IndyAgent", [pk], routing_keys, my_endpoint
-        )
-        did_doc.set(service)
+        if svc_endpoint:
+            service = Service(
+                did_info.did, "indy", "IndyAgent", [pk], routing_keys, svc_endpoint
+            )
+            did_doc.set(service)
 
         return did_doc
 

aries_cloudagent/messaging/connections/routes.py

@@ -7,7 +7,7 @@
 
 from ...storage.error import StorageNotFoundError
 
-from ..valid import UUIDFour
+from ..valid import IndyDID, UUIDFour
 
 from .manager import ConnectionManager
 from .messages.connection_invitation import (
@@ -30,16 +30,40 @@ class InvitationResultSchema(Schema):
     """Result schema for a new connection invitation."""
 
     connection_id = fields.Str(
-        description="Connection identifier",
-        example=UUIDFour.EXAMPLE,
+        description="Connection identifier", example=UUIDFour.EXAMPLE
     )
     invitation = fields.Nested(ConnectionInvitationSchema())
     invitation_url = fields.Str(
         description="Invitation URL",
-        example="http:192.168.56.101:8020/invite?c_i=eyJAdHlwZSI6Li4ufQ=="
+        example="http://192.168.56.101:8020/invite?c_i=eyJAdHlwZSI6Li4ufQ==",
     )
 
 
+class ConnectionStaticRequestSchema(Schema):
+    """Request schema for a new static connection."""
+
+    my_seed = fields.Str(description="Seed to use for the local DID", required=False)
+    my_did = fields.Str(
+        description="Local DID", required=False, example=IndyDID.EXAMPLE
+    )
+    their_seed = fields.Str(
+        description="Seed to use for the remote DID", required=False
+    )
+    their_did = fields.Str(
+        description="Remote DID", required=False, example=IndyDID.EXAMPLE
+    )
+    their_verkey = fields.Str(description="Remote verification key", required=False)
+    their_endpoint = fields.Str(
+        description="URL endpoint for the other party",
+        required=False,
+        example="http://192.168.56.101:5000",
+    )
+    their_role = fields.Str(
+        description="Role to assign to this connection", required=False
+    )
+    alias = fields.Str(description="Alias to assign to this connection", required=False)
+
+
 def connection_sort_key(conn):
     """Get the sorting key for a particular connection."""
     if conn["state"] == ConnectionRecord.STATE_INACTIVE:
@@ -401,6 +425,39 @@ async def connections_remove(request: web.BaseRequest):
     return web.json_response({})
 
 
+@docs(tags=["connection"], summary="Create a new static connection")
+@request_schema(ConnectionStaticRequestSchema())
+@response_schema(ConnectionRecordSchema(), 200)
+async def connections_create_static(request: web.BaseRequest):
+    """
+    Request handler for creating a new static connection.
+
+    Args:
+        request: aiohttp request object
+
+    Returns:
+        The new connection record
+
+    """
+    context = request.app["request_context"]
+    body = await request.json()
+
+    connection_mgr = ConnectionManager(context)
+    connection = await connection_mgr.create_static_connection(
+        my_seed=body.get("my_seed") or None,
+        my_did=body.get("my_did") or None,
+        their_seed=body.get("their_seed") or None,
+        their_did=body.get("their_did") or None,
+        their_verkey=body.get("their_verkey") or None,
+        their_endpoint=body.get("their_endpoint") or None,
+        their_role=body.get("their_role") or None,
+        alias=body.get("alias") or None,
+    )
+    result = connection.serialize()
+
+    return web.json_response(result)
+
+
 async def register(app: web.Application):
     """Register routes."""
 

aries_cloudagent/wallet/crypto.py

@@ -77,13 +77,13 @@ def random_seed() -> bytes:
 
 def seed_to_did(seed: str) -> str:
     """
-    Derive a did from a seed value.
+    Derive a DID from a seed value.
 
     Args:
         seed: The seed to derive
 
     Returns:
-        The did derived from the seed
+        The DID derived from the seed
 
     """
     seed = validate_seed(seed)