endorser info in multi ledger config + tests

Signed-off-by: Shaanjot Gill <[email protected]>

aries_cloudagent/askar/profile.py

@@ -162,6 +162,16 @@ def bind_providers(self):
                     ref(self),
                 ),
             )
+            if (
+                "endorser_alias" in write_ledger_config
+                and "endorser_did" in write_ledger_config
+            ):
+                self.settings["endorser.endorser_alias"] = write_ledger_config.get(
+                    "endorser_alias"
+                )
+                self.settings["endorser.endorser_public_did"] = write_ledger_config.get(
+                    "endorser_did"
+                )
         elif self.ledger_pool:
             injector.bind_provider(
                 BaseLedger, ClassProvider(IndyVdrLedger, self.ledger_pool, ref(self))

aries_cloudagent/askar/tests/test_profile.py

@@ -6,6 +6,7 @@
 
 from ...askar.profile import AskarProfile
 from ...config.injection_context import InjectionContext
+from ...ledger.base import BaseLedger
 
 from .. import profile as test_module
 
@@ -24,6 +25,41 @@ async def test_init_success(open_store):
     assert askar_profile.opened == open_store
 
 
+@pytest.mark.asyncio
+async def test_init_multi_ledger(open_store):
+    context = InjectionContext(
+        settings={
+            "ledger.ledger_config_list": [
+                {
+                    "id": "BCovrinDev",
+                    "is_production": True,
+                    "is_write": True,
+                    "endorser_did": "9QPa6tHvBHttLg6U4xvviv",
+                    "endorser_alias": "endorser_dev",
+                    "genesis_transactions": mock.MagicMock(),
+                },
+                {
+                    "id": "SovrinStagingNet",
+                    "is_production": False,
+                    "genesis_transactions": mock.MagicMock(),
+                },
+            ]
+        }
+    )
+    askar_profile = AskarProfile(
+        open_store,
+        context=context,
+    )
+
+    assert askar_profile.opened == open_store
+    assert askar_profile.settings["endorser.endorser_alias"] == "endorser_dev"
+    assert (
+        askar_profile.settings["endorser.endorser_public_did"]
+        == "9QPa6tHvBHttLg6U4xvviv"
+    )
+    assert (askar_profile.inject_or(BaseLedger)).pool_name == "BCovrinDev"
+
+
 @pytest.mark.asyncio
 async def test_remove_success(open_store):
     openStore = open_store

aries_cloudagent/config/ledger.py

@@ -91,22 +91,25 @@ async def load_multiple_genesis_transactions_from_config(settings: Settings):
         ledger_id = config.get("id") or str(uuid.uuid4())
         if is_write_ledger:
             write_ledger_set = True
-        ledger_txns_list.append(
-            {
-                "id": ledger_id,
-                "is_production": (
-                    True
-                    if config.get("is_production") is None
-                    else config.get("is_production")
-                ),
-                "is_write": is_write_ledger,
-                "genesis_transactions": txns,
-                "keepalive": int(config.get("keepalive", 5)),
-                "read_only": bool(config.get("read_only", False)),
-                "socks_proxy": config.get("socks_proxy"),
-                "pool_name": config.get("pool_name", ledger_id),
-            }
-        )
+        config_item = {
+            "id": ledger_id,
+            "is_production": (
+                True
+                if config.get("is_production") is None
+                else config.get("is_production")
+            ),
+            "is_write": is_write_ledger,
+            "genesis_transactions": txns,
+            "keepalive": int(config.get("keepalive", 5)),
+            "read_only": bool(config.get("read_only", False)),
+            "socks_proxy": config.get("socks_proxy"),
+            "pool_name": config.get("pool_name", ledger_id),
+        }
+        if "endorser_alias" in config:
+            config_item["endorser_alias"] = config.get("endorser_alias")
+        if "endorser_did" in config:
+            config_item["endorser_did"] = config.get("endorser_did")
+        ledger_txns_list.append(config_item)
     if not write_ledger_set and not (
         settings.get("ledger.genesis_transactions")
         or settings.get("ledger.genesis_file")

aries_cloudagent/config/tests/test_ledger.py

@@ -293,6 +293,8 @@ async def test_load_multiple_genesis_transactions_from_config_a(self):
                 "read_only": False,
                 "socks_proxy": None,
                 "pool_name": "sovrinMain",
+                "endorser_did": "9QPa6tHvBHttLg6U4xvviv",
+                "endorser_alias": "endorser_main",
             },
             {
                 "id": "sovrinStaging",
@@ -322,6 +324,8 @@ async def test_load_multiple_genesis_transactions_from_config_a(self):
                     "is_production": True,
                     "is_write": True,
                     "genesis_transactions": TEST_GENESIS_TXNS,
+                    "endorser_did": "9QPa6tHvBHttLg6U4xvviv",
+                    "endorser_alias": "endorser_main",
                 },
                 {
                     "id": "sovrinStaging",

aries_cloudagent/indy/sdk/profile.py

@@ -130,6 +130,16 @@ def bind_providers(self):
                     ref(self),
                 ),
             )
+            if (
+                "endorser_alias" in write_ledger_config
+                and "endorser_did" in write_ledger_config
+            ):
+                self.settings["endorser.endorser_alias"] = write_ledger_config.get(
+                    "endorser_alias"
+                )
+                self.settings["endorser.endorser_public_did"] = write_ledger_config.get(
+                    "endorser_did"
+                )
         elif self.ledger_pool:
             injector.bind_provider(
                 BaseLedger, ClassProvider(IndySdkLedger, self.ledger_pool, ref(self))

aries_cloudagent/indy/sdk/tests/test_profile.py

@@ -6,7 +6,9 @@
 
 from ....config.injection_context import InjectionContext
 from ....core.error import ProfileError
+from ....ledger.base import BaseLedger
 from ....ledger.indy import IndySdkLedgerPool
+
 from ..profile import IndySdkProfile
 from ..wallet_setup import IndyOpenWallet, IndyWalletConfig
 
@@ -35,6 +37,41 @@ async def profile(open_wallet):
     profile._finalizer()
 
 
+@pytest.mark.asyncio
+async def test_init_multi_ledger(open_wallet):
+    context = InjectionContext(
+        settings={
+            "ledger.ledger_config_list": [
+                {
+                    "id": "BCovrinDev",
+                    "is_production": True,
+                    "is_write": True,
+                    "endorser_did": "9QPa6tHvBHttLg6U4xvviv",
+                    "endorser_alias": "endorser_dev",
+                    "genesis_transactions": async_mock.MagicMock(),
+                },
+                {
+                    "id": "SovrinStagingNet",
+                    "is_production": False,
+                    "genesis_transactions": async_mock.MagicMock(),
+                },
+            ]
+        }
+    )
+    askar_profile = IndySdkProfile(
+        open_wallet,
+        context=context,
+    )
+
+    assert askar_profile.opened == open_wallet
+    assert askar_profile.settings["endorser.endorser_alias"] == "endorser_dev"
+    assert (
+        askar_profile.settings["endorser.endorser_public_did"]
+        == "9QPa6tHvBHttLg6U4xvviv"
+    )
+    assert (askar_profile.inject_or(BaseLedger)).pool_name == "BCovrinDev"
+
+
 @pytest.mark.asyncio
 async def test_properties(profile: IndySdkProfile):
     assert profile.name == "test-profile"

aries_cloudagent/ledger/multiple_ledger/base_manager.py

@@ -19,6 +19,10 @@ class BaseMultipleLedgerManager(ABC):
     def __init__(self, profile: Profile):
         """Initialize Multiple Ledger Manager."""
 
+    @abstractmethod
+    def get_endorser_info_for_ledger(self, ledger_id: str) -> Optional[Tuple[str, str]]:
+        """Return endorser alias, did tuple for provided ledger, if available."""
+
     @abstractmethod
     async def get_write_ledgers(self) -> List[str]:
         """Return write ledger."""

aries_cloudagent/ledger/multiple_ledger/indy_manager.py

@@ -34,6 +34,7 @@ def __init__(
         production_ledgers: OrderedDict = OrderedDict(),
         non_production_ledgers: OrderedDict = OrderedDict(),
         writable_ledgers: set = set(),
+        endorser_map: dict = {},
         cache_ttl: int = None,
     ):
         """Initialize MultiIndyLedgerManager.
@@ -49,13 +50,21 @@ def __init__(
         self.production_ledgers = production_ledgers
         self.non_production_ledgers = non_production_ledgers
         self.writable_ledgers = writable_ledgers
+        self.endorser_map = endorser_map
         self.executor = concurrent.futures.ThreadPoolExecutor(max_workers=5)
         self.cache_ttl = cache_ttl
 
     async def get_write_ledgers(self) -> List[str]:
         """Return the write IndySdkLedger instance."""
         return list(self.writable_ledgers)
 
+    def get_endorser_info_for_ledger(self, ledger_id: str) -> Optional[Tuple[str, str]]:
+        """Return endorser alias, did tuple for provided ledger, if available."""
+        endorser_info = self.endorser_map.get(ledger_id)
+        if not endorser_info:
+            return None
+        return (endorser_info["endorser_alias"], endorser_info["endorser_did"])
+
     async def get_ledger_inst_by_id(self, ledger_id: str) -> Optional[BaseLedger]:
         """Return BaseLedger instance."""
         return self.production_ledgers.get(
@@ -92,6 +101,11 @@ async def set_profile_write_ledger(self, ledger_id: str, profile: Profile) -> st
             profile.context.injector.bind_instance(
                 BaseLedger, multi_ledgers.get(ledger_id)
             )
+            endorser_info = self.get_endorser_info_for_ledger(ledger_id)
+            if endorser_info:
+                endorser_alias, endorser_did = endorser_info
+                profile.context.settings["endorser.endorser_alias"] = endorser_alias
+                profile.context.settings["endorser.endorser_public_did"] = endorser_did
             return ledger_id
         raise MultipleLedgerManagerError(f"No ledger info found for {ledger_id}.")
 

aries_cloudagent/ledger/multiple_ledger/indy_vdr_manager.py

@@ -34,6 +34,7 @@ def __init__(
         production_ledgers: OrderedDict = OrderedDict(),
         non_production_ledgers: OrderedDict = OrderedDict(),
         writable_ledgers: set = set(),
+        endorser_map: dict = {},
         cache_ttl: int = None,
     ):
         """Initialize MultiIndyLedgerManager.
@@ -49,13 +50,21 @@ def __init__(
         self.production_ledgers = production_ledgers
         self.non_production_ledgers = non_production_ledgers
         self.writable_ledgers = writable_ledgers
+        self.endorser_map = endorser_map
         self.executor = concurrent.futures.ThreadPoolExecutor(max_workers=5)
         self.cache_ttl = cache_ttl
 
     async def get_write_ledgers(self) -> List[str]:
         """Return the write IndyVdrLedger instance."""
         return list(self.writable_ledgers)
 
+    def get_endorser_info_for_ledger(self, ledger_id: str) -> Optional[Tuple[str, str]]:
+        """Return endorser alias, did tuple for provided ledger, if available."""
+        endorser_info = self.endorser_map.get(ledger_id)
+        if not endorser_info:
+            return None
+        return (endorser_info["endorser_alias"], endorser_info["endorser_did"])
+
     async def get_prod_ledgers(self) -> Mapping:
         """Return production ledgers mapping."""
         return self.production_ledgers
@@ -75,6 +84,11 @@ async def set_profile_write_ledger(self, ledger_id: str, profile: Profile) -> st
             profile.context.injector.bind_instance(
                 BaseLedger, multi_ledgers.get(ledger_id)
             )
+            endorser_info = self.get_endorser_info_for_ledger(ledger_id)
+            if endorser_info:
+                endorser_alias, endorser_did = endorser_info
+                profile.context.settings["endorser.endorser_alias"] = endorser_alias
+                profile.context.settings["endorser.endorser_public_did"] = endorser_did
             return ledger_id
         raise MultipleLedgerManagerError(f"No ledger info found for {ledger_id}.")
 

aries_cloudagent/ledger/multiple_ledger/manager_provider.py

@@ -72,6 +72,7 @@ def provide(self, settings: BaseSettings, injector: BaseInjector):
                     indy_sdk_production_ledgers = OrderedDict()
                     indy_sdk_non_production_ledgers = OrderedDict()
                     ledger_config_list = settings.get_value("ledger.ledger_config_list")
+                    ledger_endorser_map = {}
                     write_ledgers = set()
                     for config in ledger_config_list:
                         keepalive = config.get("keepalive")
@@ -83,37 +84,43 @@ def provide(self, settings: BaseSettings, injector: BaseInjector):
                         pool_name = config.get("pool_name")
                         ledger_is_production = config.get("is_production")
                         ledger_is_write = config.get("is_write")
+                        ledger_endorser_alias = config.get("endorser_alias")
+                        ledger_endorser_did = config.get("endorser_did")
+                        ledger_pool = pool_class(
+                            pool_name,
+                            keepalive=keepalive,
+                            cache=cache,
+                            genesis_transactions=genesis_transactions,
+                            read_only=read_only,
+                            socks_proxy=socks_proxy,
+                        )
+                        ledger_instance = ledger_class(
+                            pool=ledger_pool,
+                            profile=self.root_profile,
+                        )
                         if ledger_is_write:
                             write_ledgers.add(ledger_id)
+                        if ledger_is_production:
+                            indy_sdk_production_ledgers[ledger_id] = ledger_instance
                         else:
-                            ledger_pool = pool_class(
-                                pool_name,
-                                keepalive=keepalive,
-                                cache=cache,
-                                genesis_transactions=genesis_transactions,
-                                read_only=read_only,
-                                socks_proxy=socks_proxy,
-                            )
-                            ledger_instance = ledger_class(
-                                pool=ledger_pool,
-                                profile=self.root_profile,
-                            )
-                            if ledger_is_production:
-                                indy_sdk_production_ledgers[ledger_id] = ledger_instance
-                            else:
-                                indy_sdk_non_production_ledgers[
-                                    ledger_id
-                                ] = ledger_instance
+                            indy_sdk_non_production_ledgers[ledger_id] = ledger_instance
+                        if ledger_endorser_alias and ledger_endorser_did:
+                            ledger_endorser_map[ledger_id] = {
+                                "endorser_alias": ledger_endorser_alias,
+                                "endorser_did": ledger_endorser_did,
+                            }
                     self._inst[manager_type] = manager_class(
                         self.root_profile,
                         production_ledgers=indy_sdk_production_ledgers,
                         non_production_ledgers=indy_sdk_non_production_ledgers,
                         writable_ledgers=write_ledgers,
+                        endorser_map=ledger_endorser_map,
                     )
                 else:
                     indy_vdr_production_ledgers = OrderedDict()
                     indy_vdr_non_production_ledgers = OrderedDict()
                     ledger_config_list = settings.get_value("ledger.ledger_config_list")
+                    ledger_endorser_map = {}
                     write_ledgers = set()
                     for config in ledger_config_list:
                         keepalive = config.get("keepalive")
@@ -125,6 +132,8 @@ def provide(self, settings: BaseSettings, injector: BaseInjector):
                         pool_name = config.get("pool_name")
                         ledger_is_production = config.get("is_production")
                         ledger_is_write = config.get("is_write")
+                        ledger_endorser_alias = config.get("endorser_alias")
+                        ledger_endorser_did = config.get("endorser_did")
                         ledger_pool = pool_class(
                             pool_name,
                             keepalive=keepalive,
@@ -143,11 +152,17 @@ def provide(self, settings: BaseSettings, injector: BaseInjector):
                             indy_vdr_production_ledgers[ledger_id] = ledger_instance
                         else:
                             indy_vdr_non_production_ledgers[ledger_id] = ledger_instance
+                        if ledger_endorser_alias and ledger_endorser_did:
+                            ledger_endorser_map[ledger_id] = {
+                                "endorser_alias": ledger_endorser_alias,
+                                "endorser_did": ledger_endorser_did,
+                            }
                     self._inst[manager_type] = manager_class(
                         self.root_profile,
                         production_ledgers=indy_vdr_production_ledgers,
                         non_production_ledgers=indy_vdr_non_production_ledgers,
                         writable_ledgers=write_ledgers,
+                        endorser_map=ledger_endorser_map,
                     )
             except ClassNotFoundError as err:
                 raise InjectionError(