Adding support for the issue-credential protocol family. (#28)

Signed-off-by: Keith Smith <[email protected]>

Co-authored-by: Daniel Bluhm <[email protected]>

Author: Keith Smith

config.sample.toml

@@ -9,12 +9,24 @@ port = 3000
 endpoint = "http://localhost:3000"
 backchannel = 'default.ManualBackchannel'
 
+#
+# The 'provider' variable is used to dynamically load a provider.
+# A provider is required to test the issue-credential protocol family.
+# The Indy provider is specified as follows:
+#    provider = 'indy_provider.IndyProvider'
+# The Indy provider requires 'genesis_url' to be set to a URL from which the genesis
+# transaction file can be downloaded.  For example, it could be similar to the following:
+#    genesis_url = 'http://ledger/sandbox/pool_transactions_genesis'
+#
+
 # List of regular expressions used to select tests.
 # If a test name matches at least one regex in this list, it will be selected
 # for execution. matches the @meta data in the desired tests, 
 # for example 'connections,1.0,inviter,response-post-sig-verify-valid'.
 tests = [
     "connections.*",
+    "discover-features.*",
+    # "issue-credential.*",
 ]
 
 [config.subject]

indy_provider.py

@@ -0,0 +1,137 @@
+import json
+import aiohttp
+import base64
+import time
+import sys
+import hashlib
+
+from protocol_tests.provider import Provider
+from protocol_tests.issue_credential.provider import IssueCredentialProvider
+from indy import anoncreds, wallet, ledger, pool, crypto, did, pairwise, non_secrets, ledger, wallet, blob_storage
+from indy.error import IndyError, ErrorCode
+
+
+class IndyProvider(Provider, IssueCredentialProvider):
+    """
+    The indy provider isolates all indy-specific code required by the test suite.
+    """
+
+    async def setup(self, config):
+        if not 'genesis_url' in config:
+            raise Exception(
+                "The Indy provider requires a 'genesis_url' value in config.toml")
+        self.genesis_url = config['genesis_url']
+        self.pool_name = config.get('pool_name', 'arie-test')
+        id = config.get('name', 'test')
+        key = config.get('pass', 'testpw')
+        seed = config.get('seed', '000000000000000000000000Steward1')
+        self.cfg = json.dumps({'id': id})
+        self.creds = json.dumps({'key': key})
+        self.seed = json.dumps({'seed': seed})
+        try:
+            await wallet.delete_wallet(self.cfg, self.creds)
+        except Exception as e:
+            pass
+        await wallet.create_wallet(self.cfg, self.creds)
+        self.wallet = await wallet.open_wallet(self.cfg, self.creds)
+        self.master_secret_id = await anoncreds.prover_create_master_secret(self.wallet, None)
+        (self.did, self.verkey) = await did.create_and_store_my_did(self.wallet, self.seed)
+        # Download the genesis file
+        resp = await aiohttp.ClientSession().get(self.genesis_url)
+        genesis = await resp.read()
+        genesisFileName = "genesis.aries-test"
+        with open(genesisFileName, 'wb') as output:
+            output.write(genesis)
+        await self._open_pool({'genesis_txn': genesisFileName})
+
+    async def issue_credential_v1_0_issuer_create_credential_schema(self, name: str, version: str, attrs: [str]) -> str:
+        (schema_id, schema) = await anoncreds.issuer_create_schema(
+            self.did, name, version, json.dumps(attrs))
+        schema_request = await ledger.build_schema_request(self.did, schema)
+        await ledger.sign_and_submit_request(self.pool,
+                                             self.wallet,
+                                             self.did,
+                                             schema_request)
+        return schema_id
+
+    async def issue_credential_v1_0_issuer_create_credential_definition(self, schema_id) -> str:
+        request = await ledger.build_get_schema_request(self.did, schema_id)
+        response = await ledger.submit_request(self.pool, request)
+        (_, schema) = await ledger.parse_get_schema_response(response)
+        (cred_def_id, cred_def_json) = await anoncreds.issuer_create_and_store_credential_def(
+            self.wallet, self.did, schema, 'TAG1', 'CL', '{"support_revocation": false}')
+        cred_def_request = await ledger.build_cred_def_request(self.did, cred_def_json)
+        await ledger.sign_and_submit_request(self.pool, self.wallet, self.did, cred_def_request)
+        return cred_def_id
+
+    async def issue_credential_v1_0_issuer_create_credential_offer(self, cred_def_id: str) -> (str, any):
+        offer = await anoncreds.issuer_create_credential_offer(self.wallet, cred_def_id)
+        attach = base64.b64encode(offer.encode()).decode()
+        return (attach, offer)
+
+    async def issue_credential_v1_0_issuer_create_credential(self, offer: any, b64_request_attach: any, attrs: dict) -> str:
+        req = base64.b64decode(b64_request_attach).decode()
+        attrs = json.dumps(self._encode_attrs(attrs))
+        (cred_json, _, _) = await anoncreds.issuer_create_credential(self.wallet, offer, req, attrs, None, None)
+        attach = base64.b64encode(cred_json.encode()).decode()
+        return attach
+
+    async def issue_credential_v1_0_holder_create_credential_request(self, b64_offer_attach: str) -> (str, dict):
+        offer = json.loads(base64.b64decode(b64_offer_attach))
+        credDefId = offer['cred_def_id']
+        # Get the cred def from the ledger
+        (_, credDef) = await self._get_cred_def(credDefId)
+        # Create the credential request
+        (req_data, req_metadata) = await anoncreds.prover_create_credential_req(
+            self.wallet, self.did, json.dumps(offer), credDef, self.master_secret_id)
+        b64_request_attach = base64.b64encode(req_data.encode()).decode()
+        store_credential_passback = {
+            "req_metadata": req_metadata,
+            "cred_def": credDef
+        }
+        return (b64_request_attach, store_credential_passback)
+
+    async def issue_credential_v1_0_holder_store_credential(self, b64_credential_attach: str, store_credential_passback: dict):
+        cred = base64.b64decode(b64_credential_attach).decode()
+        pb = store_credential_passback
+        await anoncreds.prover_store_credential(self.wallet, None, pb["req_metadata"], cred, pb["cred_def"], None)
+
+    async def _get_cred_def(self, credDefId):
+        req = await ledger.build_get_cred_def_request(self.did, credDefId)
+        resp = await ledger.submit_request(self.pool, req)
+        credDef = await ledger.parse_get_cred_def_response(resp)
+        return credDef
+
+    async def _open_pool(self, cfg):
+        # Create the pool, but ignore the error if it already exists
+        await pool.set_protocol_version(2)
+        try:
+            await pool.create_pool_ledger_config(self.pool_name, json.dumps(cfg))
+        except IndyError as e:
+            if e.error_code != ErrorCode.PoolLedgerConfigAlreadyExistsError:
+                raise e
+        self.pool = await pool.open_pool_ledger(self.pool_name, json.dumps(cfg))
+
+    def _encode_attrs(self, attrs: dict) -> dict:
+        result = {}
+        for name, val in attrs.items():
+            result[name] = {
+                'raw': val,
+                'encoded': self._encode_attr(val),
+            }
+        return result
+
+    def _encode_attr(self, value) -> str:
+        if value is None:
+            return '4294967297'  # sentinel 2**32 + 1
+        s = str(value)
+        try:
+            i = int(value)
+            if 0 <= i < 2**32:  # it's an i32, leave it (as numeric string)
+                return s
+        except (ValueError, TypeError):
+            pass
+        # Compute sha256 decimal string
+        hash = hashlib.sha256(value.encode()).digest()
+        num = int.from_bytes(hash, byteorder=sys.byteorder, signed=False)
+        return str(num)

protocol_tests/__init__.py

@@ -6,6 +6,7 @@
 
 from aries_staticagent import StaticConnection, Message, crypto
 from .backchannel import Backchannel
+from .provider import Provider
 
 
 def _recipients_from_packed_message(packed_message: bytes) -> Iterable[str]:
@@ -41,6 +42,7 @@ class Suite:
     def __init__(self):
         self.frontchannels: Dict[str, StaticConnection] = {}
         self._backchannel = None
+        self._provider = None
         self._reply = None
 
     @property
@@ -52,6 +54,15 @@ def set_backchannel(self, backchannel: Backchannel):
         """Set backchannel."""
         self._backchannel = backchannel
 
+    @property
+    def provider(self):
+        """Return a reference to the provider (self)."""
+        return self._provider
+
+    def set_provider(self, provider: Provider):
+        """Set provider."""
+        self._provider = provider
+
     @contextmanager
     def reply(self, handler):
         """Handle potential to reply."""

protocol_tests/conftest.py

@@ -20,6 +20,7 @@
 
 # pylint: disable=redefined-outer-name
 
+
 @pytest.fixture(scope='session')
 def event_loop():
     """ Create a session scoped event loop.
@@ -36,11 +37,13 @@ def config(pytestconfig):
     """
     yield pytestconfig.suite_config
 
+
 @pytest.fixture(scope='session')
 def suite():
     """Get channel manager for test suite."""
     yield Suite()
 
+
 @pytest.fixture(scope='session')
 async def http_endpoint(config, suite):
     """Create http server task."""
@@ -86,6 +89,20 @@ async def backchannel(config, http_endpoint, suite):
     yield suite.backchannel
 
 
+@pytest.fixture(scope='session')
+async def provider(config, suite):
+    """Get provider to test subject."""
+    if not 'provider' in config and not config['provider']:
+        raise "No 'provider' was specified in the config file"
+    path_parts = config['provider'].split('.')
+    mod_path, class_name = '.'.join(path_parts[:-1]), path_parts[-1]
+    mod = import_module(mod_path)
+    provider_class = getattr(mod, class_name)
+    suite.set_provider(provider_class())
+    await suite.provider.setup(config)
+    yield suite.provider
+
+
 @pytest.fixture(scope='session')
 def temporary_channel(http_endpoint, suite):
     """Get contextmanager for using a temporary channel."""