ledger config fix

.github/workflows/main.yml

@@ -29,7 +29,7 @@ jobs:
             password: ${{ secrets.REGISTRY_PASSWORD }}
         - run: |
             cd $GITHUB_WORKSPACE
-            docker build . -t ${{ secrets.REGISTRY_LOGIN_SERVER }}/aries-cloud-agency-image:latest --build-arg AGENCY_INBOUND_PORT=7000 --build-arg AGENCY_ADMIN_PORT=2000 --build-arg AGENCY_ENDPOINT=${{ secrets.AGENCY_ENDPOINT }} --build-arg AGENCY_ADMIN_API_KEY=${{ secrets.AGENCY_ADMIN_API_KEY }} --build-arg GENESIS_URL=${{ secrets.GENESIS_URL }} --build-arg AGENCY_HOSTNAME=${{ secrets.AGENCY_HOSTNAME }}
+            docker build . -t ${{ secrets.REGISTRY_LOGIN_SERVER }}/aries-cloud-agency-image:latest --build-arg AGENCY_INBOUND_PORT=7000 --build-arg AGENCY_ADMIN_PORT=2000 --build-arg AGENCY_ENDPOINT=${{ secrets.AGENCY_ENDPOINT }} --build-arg AGENCY_ADMIN_API_KEY=${{ secrets.AGENCY_ADMIN_API_KEY }} --build-arg GENESIS_URL=${{ secrets.GENESIS_URL }}
             docker push ${{ secrets.REGISTRY_LOGIN_SERVER }}/aries-cloud-agency-image:latest
 
         - name: 'Deploy to Azure Agency Container Instance'

Dockerfile

@@ -6,7 +6,6 @@ ARG AGENCY_ADMIN_PORT
 ARG AGENCY_ADMIN_API_KEY
 ARG AGENCY_INBOUND_PORT
 ARG AGENCY_ENDPOINT
-ARG AGENCY_HOSTNAME
 ARG GENESIS_URL
 
 RUN pip install aries-cloudagent
@@ -19,8 +18,7 @@ ENV admin_api_key=$AGENCY_ADMIN_API_KEY \
     admin_port=$AGENCY_ADMIN_PORT \
     agency_endpoint=$AGENCY_ENDPOINT \
     inbound_port=$AGENCY_INBOUND_PORT \
-    genesis_url=$GENESIS_URL \
-    host_name=$AGENCY_HOSTNAME
+    genesis_url=$GENESIS_URL
 
 EXPOSE 7000 2000
 

aries_cloudagency/admin/server.py

@@ -34,6 +34,7 @@
 from ..config.wallet import wallet_config
 from ..storage.base import BaseStorage
 from ..storage.indy import IndyStorage
+from ..config.ledger import ledger_config
 
 LOGGER = logging.getLogger(__name__)
 
@@ -240,7 +241,7 @@ async def agency_middleware(request, handler):
 
                 storage = IndyStorage(wallet_instance)
                 self.context.injector.bind_instance(BaseStorage, storage)
-                await wallet_config(self.context, True)
+                await wallet_config(self.context)
                 app["request_context"] = self.context
             return await handler(request)
 

aries_cloudagency/agency/server.py

@@ -21,7 +21,6 @@ def str_to_bool(s):
 admin_port = os.getenv("admin_port", "2000")
 agency_endpoint = os.getenv("agency_endpoint", "http://0.0.0.0")
 inbound_port = os.getenv("inbound_port", "7000")
-agency_hostname = os.getenv("host_name", "0.0.0.0")
 genesis_url = os.getenv("genesis_url", "http://greenlight.bcovrin.vonx.io/genesis")
 
 
@@ -32,10 +31,10 @@ async def start():
         contextBuilder.settings.set_default("admin.admin_insecure_mode", admin_insecure_mode)
     else:
         contextBuilder.settings.set_default("admin.admin_api_key", admin_api_key)
-    contextBuilder.settings.set_default("admin.host", agency_hostname)
+    contextBuilder.settings.set_default("admin.host", "0.0.0.0")
     contextBuilder.settings.set_default("admin.port", admin_port)
     contextBuilder.settings.set_default("admin.webhook_urls", "")
-    contextBuilder.settings.set_default("transport.inbound_configs", [["http", agency_hostname, inbound_port]])
+    contextBuilder.settings.set_default("transport.inbound_configs", [["http", "0.0.0.0", inbound_port]])
     contextBuilder.settings.set_default("transport.outbound_configs", ["http"])
 
     contextBuilder.settings.set_default("default_label", "Aries Cloud Agency")

aries_cloudagency/agency/wallet.py

@@ -52,8 +52,8 @@ async def close(name, key):
 async def get(name, key):
     wlt = open_wallets.get(name)
     if wlt:
-        print("Wallet already exist!")
+        # print("Wallet already exist!")
         return wlt
     else:
-        print("Opening new wallet!")
+        # print("Opening new wallet!")
         return await open(name, key)

aries_cloudagency/config/ledger.py

@@ -80,6 +80,51 @@ async def ledger_config(
     return True
 
 
+async def agency_ledger_config(
+    context: InjectionContext, provision: bool = False
+) -> bool:
+    """Perform Indy ledger configuration."""
+
+    # Fetch genesis transactions if necessary
+    if not context.settings.get("ledger.genesis_transactions"):
+        if context.settings.get("ledger.genesis_url"):
+            context.settings[
+                "ledger.genesis_transactions"
+            ] = await fetch_genesis_transactions(context.settings["ledger.genesis_url"])
+        elif context.settings.get("ledger.genesis_file"):
+            try:
+                genesis_path = context.settings["ledger.genesis_file"]
+                LOGGER.info("Reading genesis transactions from: %s", genesis_path)
+                with open(genesis_path, "r") as genesis_file:
+                    context.settings["ledger.genesis_transactions"] = genesis_file.read(
+                        -1
+                    )
+            except IOError as e:
+                raise ConfigError("Error reading genesis transactions") from e
+
+    ledger: BaseLedger = await context.inject(BaseLedger, required=False)
+    if not ledger:
+        LOGGER.info("Ledger instance not provided")
+        return False
+    elif ledger.LEDGER_TYPE != "indy":
+        LOGGER.info("Non-indy ledger provided")
+        return False
+
+    async with ledger:
+        # Check transaction author agreement acceptance
+        taa_info = await ledger.get_txn_author_agreement()
+        if taa_info["taa_required"]:
+            taa_accepted = await ledger.get_latest_txn_author_acceptance()
+            if (
+                not taa_accepted
+                or taa_info["taa_record"]["digest"] != taa_accepted["digest"]
+            ):
+                if not await accept_taa(ledger, taa_info, provision):
+                    return False
+
+    return True
+
+
 async def accept_taa(ledger: BaseLedger, taa_info, provision: bool = False) -> bool:
     """Perform TAA acceptance."""
 

aries_cloudagency/core/conductor.py

@@ -34,6 +34,8 @@
 
 from .dispatcher import Dispatcher
 
+from ..config.ledger import agency_ledger_config
+
 LOGGER = logging.getLogger(__name__)
 
 
@@ -140,15 +142,19 @@ async def start(self) -> None:
 
         context = self.context
 
-        # Disabled for agency
+        # Disabling agent code for agency
         '''
         # Configure the wallet
         public_did = await wallet_config(context)
-
+        
         # Configure the ledger
         if not await ledger_config(context, public_did):
                     LOGGER.warning("No ledger configured")
         '''
+        # Configure ledger for Agency
+        if not await agency_ledger_config(context):
+            LOGGER.warning("No ledger configured")
+
         # Start up transports
         try:
             await self.inbound_transport_manager.start()

aries_cloudagency/protocols/issue_credential/v1_0/manager.py

@@ -334,7 +334,6 @@ async def receive_offer(self) -> V10CredentialExchange:
         cred_ex_record.credential_definition_id = cred_def_id
 
         await cred_ex_record.save(self.context, reason="receive credential offer")
-
         return cred_ex_record
 
     async def create_request(
@@ -352,75 +351,78 @@ async def create_request(
             A tuple (credential exchange record, credential request message)
 
         """
-        if cred_ex_record.state != V10CredentialExchange.STATE_OFFER_RECEIVED:
-            raise CredentialManagerError(
-                f"Credential exchange {cred_ex_record.credential_exchange_id} "
-                f"in {cred_ex_record.state} state "
-                f"(must be {V10CredentialExchange.STATE_OFFER_RECEIVED})"
-            )
+        try:
+            if cred_ex_record.state != V10CredentialExchange.STATE_OFFER_RECEIVED:
+                raise CredentialManagerError(
+                    f"Credential exchange {cred_ex_record.credential_exchange_id} "
+                    f"in {cred_ex_record.state} state "
+                    f"(must be {V10CredentialExchange.STATE_OFFER_RECEIVED})"
+                )
+
+            credential_definition_id = cred_ex_record.credential_definition_id
+            credential_offer = cred_ex_record.credential_offer
 
-        credential_definition_id = cred_ex_record.credential_definition_id
-        credential_offer = cred_ex_record.credential_offer
+            async def _create():
+                ledger: BaseLedger = await self.context.inject(BaseLedger)
+                async with ledger:
+                    credential_definition = await ledger.get_credential_definition(
+                        credential_definition_id
+                    )
 
-        async def _create():
-            ledger: BaseLedger = await self.context.inject(BaseLedger)
-            async with ledger:
-                credential_definition = await ledger.get_credential_definition(
-                    credential_definition_id
+                holder: BaseHolder = await self.context.inject(BaseHolder)
+                request_json, metadata_json = await holder.create_credential_request(
+                    credential_offer, credential_definition, holder_did
+                )
+                return {
+                    "request": json.loads(request_json),
+                    "metadata": json.loads(metadata_json),
+                }
+
+            if cred_ex_record.credential_request:
+                self._logger.warning(
+                    "create_request called multiple times for v1.0 credential exchange: %s",
+                    cred_ex_record.credential_exchange_id,
+                )
+            else:
+                if "nonce" not in credential_offer:
+                    raise CredentialManagerError("Missing nonce in credential offer")
+                nonce = credential_offer["nonce"]
+                cache_key = (
+                    f"credential_request::{credential_definition_id}::{holder_did}::{nonce}"
                 )
+                cred_req_result = None
+                cache: BaseCache = await self.context.inject(BaseCache, required=False)
+                if cache:
+                    async with cache.acquire(cache_key) as entry:
+                        if entry.result:
+                            cred_req_result = entry.result
+                        else:
+                            cred_req_result = await _create()
+                            await entry.set_result(cred_req_result, 3600)
+                if not cred_req_result:
+                    cred_req_result = await _create()
 
-            holder: BaseHolder = await self.context.inject(BaseHolder)
-            request_json, metadata_json = await holder.create_credential_request(
-                credential_offer, credential_definition, holder_did
-            )
-            return {
-                "request": json.loads(request_json),
-                "metadata": json.loads(metadata_json),
-            }
+                (
+                    cred_ex_record.credential_request,
+                    cred_ex_record.credential_request_metadata,
+                ) = (cred_req_result["request"], cred_req_result["metadata"])
 
-        if cred_ex_record.credential_request:
-            self._logger.warning(
-                "create_request called multiple times for v1.0 credential exchange: %s",
-                cred_ex_record.credential_exchange_id,
+            credential_request_message = CredentialRequest(
+                requests_attach=[
+                    CredentialRequest.wrap_indy_cred_req(cred_ex_record.credential_request)
+                ]
             )
-        else:
-            if "nonce" not in credential_offer:
-                raise CredentialManagerError("Missing nonce in credential offer")
-            nonce = credential_offer["nonce"]
-            cache_key = (
-                f"credential_request::{credential_definition_id}::{holder_did}::{nonce}"
+            credential_request_message._thread = {"thid": cred_ex_record.thread_id}
+            credential_request_message.assign_trace_decorator(
+                self.context.settings, cred_ex_record.trace
             )
-            cred_req_result = None
-            cache: BaseCache = await self.context.inject(BaseCache, required=False)
-            if cache:
-                async with cache.acquire(cache_key) as entry:
-                    if entry.result:
-                        cred_req_result = entry.result
-                    else:
-                        cred_req_result = await _create()
-                        await entry.set_result(cred_req_result, 3600)
-            if not cred_req_result:
-                cred_req_result = await _create()
-
-            (
-                cred_ex_record.credential_request,
-                cred_ex_record.credential_request_metadata,
-            ) = (cred_req_result["request"], cred_req_result["metadata"])
-
-        credential_request_message = CredentialRequest(
-            requests_attach=[
-                CredentialRequest.wrap_indy_cred_req(cred_ex_record.credential_request)
-            ]
-        )
-        credential_request_message._thread = {"thid": cred_ex_record.thread_id}
-        credential_request_message.assign_trace_decorator(
-            self.context.settings, cred_ex_record.trace
-        )
-
-        cred_ex_record.state = V10CredentialExchange.STATE_REQUEST_SENT
-        await cred_ex_record.save(self.context, reason="create credential request")
 
-        return (cred_ex_record, credential_request_message)
+            cred_ex_record.state = V10CredentialExchange.STATE_REQUEST_SENT
+            await cred_ex_record.save(self.context, reason="create credential request")
+            return (cred_ex_record, credential_request_message)
+        except Exception as ex:
+            print('EXCEPTION!')
+            print(ex)
 
     async def receive_request(self):
         """