feat: split GlobalResolver

examples/08-local-network-interaction/agent1.py

@@ -1,4 +1,5 @@
 from uagents.setup import fund_agent_if_low
+from uagents.resolver import get_agent_address
 from uagents import Agent, Context, Model
 
 
@@ -17,12 +18,13 @@ class Message(Model):
 )
 
 fund_agent_if_low(bob.wallet.address())
+print(bob.address)
 
 
 @bob.on_event("startup")
 async def register_name(ctx: Context):
     await bob.register_name()
-    print("agent bob registered address: ", bob.get_agent_address(ctx.name))
+    print("agent bob registered address: ", get_agent_address(ctx.name))
 
 
 @bob.on_message(model=Message)

src/uagents/agent.py

@@ -22,7 +22,7 @@
 from uagents.dispatch import Sink, dispatcher, JsonStr
 from uagents.models import Model, ErrorMessage
 from uagents.protocol import Protocol
-from uagents.resolver import Resolver, AlmanacResolver
+from uagents.resolver import Resolver, GlobalResolver
 from uagents.storage import KeyValueStore, get_or_create_private_keys
 from uagents.network import (
     get_ledger,
@@ -73,7 +73,7 @@ def __init__(
         self._name = name
         self._port = port if port is not None else 8000
         self._background_tasks: Set[asyncio.Task] = set()
-        self._resolver = resolve if resolve is not None else AlmanacResolver()
+        self._resolver = resolve if resolve is not None else GlobalResolver()
         self._loop = asyncio.get_event_loop_policy().get_event_loop()
 
         # initialize wallet and identity
@@ -274,18 +274,6 @@ async def register_name(self):
         await wait_for_tx_to_complete(transaction.tx_hash)
         self._logger.info("Registering name...complete")
 
-    def get_agent_address(self, name: str) -> str:
-        query_msg = {"domain_record": {"domain": f"{name}.agent"}}
-        res = self._service_contract.query(query_msg)
-        if res["record"] is not None:
-            registered_address = res["record"]["records"][0]["agent_address"]["records"]
-            if len(registered_address) > 0:
-                return registered_address[0]["address"]
-            self._logger.warning(f"Agent {self.name} registration expired")
-            return 0
-        self._logger.warning(f"Agent {self.name} is not registered")
-        return 1
-
     def on_interval(
         self,
         period: float,

src/uagents/config.py

@@ -17,7 +17,7 @@ class AgentNetwork(Enum):
 LEDGER_PREFIX = "fetch"
 USER_PREFIX = "user"
 CONTRACT_ALMANAC = "fetch1h5rhtj5m6dqjmufj5m3t4mq6l7cnd8dvaxclwmrk6tfdm0gy3lmszksf0s"
-CONTRACT_SERVICE = "fetch1yrf4xpglq02fzj50m9wn44qdq89a5vr0ufa42qa506uhwal4n79s99sp87"
+CONTRACT_NAME_SERVICE = "fetch1yrf4xpglq02fzj50m9wn44qdq89a5vr0ufa42qa506uhwal4n79s99sp87"
 REGISTRATION_FEE = 500000000000000000
 REGISTRATION_DENOM = "atestfet"
 MIN_REGISTRATION_TIME = 3600

src/uagents/context.py

@@ -174,7 +174,6 @@ async def send_raw(
             sender=self.address,
             target=destination_address,
             session=self._session,
-
             schema_digest=schema_digest,
             protocol_digest=self.get_message_protocol(schema_digest),
             expires=expires,

src/uagents/network.py

@@ -18,7 +18,7 @@
 from uagents.config import (
     AgentNetwork,
     CONTRACT_ALMANAC,
-    CONTRACT_SERVICE,
+    CONTRACT_NAME_SERVICE,
     AGENT_NETWORK,
     BLOCK_INTERVAL,
 )
@@ -83,7 +83,7 @@ def get_sequence(self, address: str) -> int:
         return sequence
 
 
-class ServiceContract(LedgerContract):
+class NameServiceContract(LedgerContract):
     def is_name_available(self, name: str):
         query_msg = {"domain_record": {"domain": f"{name}.agent"}}
         return self.query(query_msg)["is_available"]
@@ -125,11 +125,11 @@ def get_registration_tx(self, name: str, wallet_address: str, agent_address: str
         registration_msg = self._get_registration_msg(name, agent_address)
 
         transaction.add_message(
-            create_cosmwasm_execute_msg(wallet_address, CONTRACT_SERVICE, ownership_msg)
+            create_cosmwasm_execute_msg(wallet_address, CONTRACT_NAME_SERVICE, ownership_msg)
         )
         transaction.add_message(
             create_cosmwasm_execute_msg(
-                wallet_address, CONTRACT_SERVICE, registration_msg
+                wallet_address, CONTRACT_NAME_SERVICE, registration_msg
             )
         )
 
@@ -146,7 +146,7 @@ def get_registration_tx(self, name: str, wallet_address: str, agent_address: str
 
 
 _almanac_contract = AlmanacContract(None, _ledger, CONTRACT_ALMANAC)
-_service_contract = ServiceContract(None, _ledger, CONTRACT_SERVICE)
+_name_service_contract = NameServiceContract(None, _ledger, CONTRACT_NAME_SERVICE)
 
 
 def get_ledger() -> LedgerClient:
@@ -162,7 +162,7 @@ def get_almanac_contract() -> LedgerContract:
 
 
 def get_service_contract() -> LedgerContract:
-    return _service_contract
+    return _name_service_contract
 
 
 async def wait_for_tx_to_complete(

src/uagents/query.py

@@ -9,7 +9,7 @@
 from uagents.dispatch import JsonStr
 from uagents.envelope import Envelope
 from uagents.models import Model
-from uagents.resolver import Resolver, AlmanacResolver
+from uagents.resolver import Resolver, GlobalResolver
 
 
 LOGGER = get_logger("query")
@@ -22,7 +22,7 @@ async def query(
     timeout: Optional[int] = 30,
 ) -> Optional[Envelope]:
     if resolver is None:
-        resolver = AlmanacResolver()
+        resolver = GlobalResolver()
 
     # convert the message into object form
     json_message = message.json()

src/uagents/resolver.py

@@ -41,29 +41,43 @@ async def resolve(self, destination: str) -> Optional[str]:
         pass
 
 
-class AlmanacResolver(Resolver):
+class GlobalResolver(Resolver):
     async def resolve(self, destination: str) -> Optional[str]:
+        almanac_resolver = AlmanacResolver()
+        name_service_resolver = NameServiceResolver()
         address = (
             destination
             if is_agent_address(destination)
-            else get_agent_address(destination)
+            else await name_service_resolver.resolve(destination)
         )
 
         if is_agent_address(address):
-            result = query_record(address, "service")
-            if result is not None:
-                record = result.get("record") or {}
-                endpoint_list = (
-                    record.get("record", {}).get("service", {}).get("endpoints", [])
-                )
-
-                if len(endpoint_list) > 0:
-                    endpoints = [val.get("url") for val in endpoint_list]
-                    weights = [val.get("weight") for val in endpoint_list]
-                    return address, random.choices(endpoints, weights=weights)[0]
+            return await almanac_resolver.resolve(address)
+        return None, None
+
+
+class AlmanacResolver(Resolver):
+    async def resolve(self, address: str) -> Optional[str]:
+        result = query_record(address, "service")
+        if result is not None:
+            record = result.get("record") or {}
+            endpoint_list = (
+                record.get("record", {}).get("service", {}).get("endpoints", [])
+            )
+
+            if len(endpoint_list) > 0:
+                endpoints = [val.get("url") for val in endpoint_list]
+                weights = [val.get("weight") for val in endpoint_list]
+                return address, random.choices(endpoints, weights=weights)[0]
+
         return None, None
 
 
+class NameServiceResolver(Resolver):
+    async def resolve(self, name: str) -> Optional[str]:
+        return get_agent_address(name)
+
+
 class RulesBasedResolver(Resolver):
     def __init__(self, rules: Dict[str, str]):
         self._rules = rules