feat: updates to match aname contract-V2

python/examples/13-agent-name-service/agent1.py

@@ -22,7 +22,7 @@ class Message(Model):
 my_wallet = LocalWallet.from_unsafe_seed("registration test wallet")
 name_service_contract = get_name_service_contract(test=True)
 faucet = get_faucet()
-DOMAIN = "agent"
+DOMAIN = "example.agent"
 
 faucet.get_wealth(my_wallet.address())
 

python/examples/13-agent-name-service/agent2.py

@@ -12,10 +12,12 @@ class Message(Model):
  endpoint=["http://localhost:8000/submit"],
 )
 
+DOMAIN = "example.agent"
+
 
 @alice.on_interval(period=5)
 async def alice_interval_handler(ctx: Context):
- bob_name = "bob-0.agent"
+ bob_name = "bob-0" + "." + DOMAIN
  ctx.logger.info(f"Sending message to {bob_name}...")
  await ctx.send(bob_name, Message(message="Hello there bob."))
 

python/src/uagents/network.py

@@ -2,7 +2,7 @@
 
 import asyncio
 from datetime import datetime, timedelta
-from typing import Any, Optional, Dict, List
+from typing import Any, Optional, Dict, List, Union
 
 from cosmpy.aerial.contract import LedgerContract
 from cosmpy.aerial.client import (
@@ -80,6 +80,29 @@ def add_testnet_funds(wallet_address: str):
  )
 
 
+def parse_record_config(
+ record: Optional[Union[str, List[str], Dict[str, dict]]]
+) -> List[Dict[str, Any]]:
+ """
+ Parse the user-provided record configuration.
+
+ Returns:
+ List[Dict[str, Any]]: The parsed record configuration in correct format.
+ """
+ if isinstance(record, dict):
+ records = [
+ {"address": val[0], "weight": val[1].get("weight") or 1}
+ for val in record.items()
+ ]
+ elif isinstance(record, list):
+ records = [{"address": val, "weight": 1} for val in record]
+ elif isinstance(record, str):
+ records = [{"address": record, "weight": 1}]
+ else:
+ records = None
+ return records
+
+
 async def wait_for_tx_to_complete(
  tx_hash: str,
  ledger: LedgerClient,
@@ -345,14 +368,36 @@ def is_domain_public(self, domain: str):
  Returns:
  bool: True if the domain is public, False otherwise.
  """
- res = self.query({"domain_record": {"domain": f".{domain}"}})
- return res["is_public"]
+ res = self.query({"query_domain_flags": {"domain": domain.split(".")[-1]}}).get(
+ "domain_flags"
+ )
+ if res:
+ return res["web3_flags"]["is_public"]
+ return False
+
+ def get_previous_records(self, name: str, domain: str):
+ """
+ Retrieve the previous records for a given name within a specified domain.
+
+ Args:
+ name (str): The name whose records are to be retrieved.
+ domain (str): The domain within which the name is registered.
+
+ Returns:
+ A list of dictionaries, where each dictionary contains
+ details of a record associated with the given name.
+ """
+ query_msg = {"domain_record": {"domain": f"{name}.{domain}"}}
+ result = self.query(query_msg)
+ if result["record"] is not None:
+ return result["record"]["records"][0]["agent_address"]["records"]
+ return []
 
  def get_registration_tx(
  self,
  name: str,
  wallet_address: str,
- agent_address: str,
+ agent_records: List[Dict[str, Any]],
  domain: str,
  test: bool,
  ):
@@ -370,24 +415,36 @@ def get_registration_tx(
  Optional[Transaction]: The registration transaction, or None if the name is not
  available or not owned by the wallet address.
  """
- if not self.is_name_available(name, domain) and not self.is_owner(
- name, domain, wallet_address
- ):
+ transaction = Transaction()
+
+ contract = (
+ TESTNET_CONTRACT_NAME_SERVICE if test else MAINNET_CONTRACT_NAME_SERVICE
+ )
+
+ if self.is_name_available(name, domain):
+ price_per_second = self.query({"contract_state": {}})["price_per_second"]
+ amount = int(price_per_second["amount"]) * 86400
+ denom = price_per_second["denom"]
+
+ registration_msg = {"register": {"domain": f"{name}.{domain}"}}
+
+ transaction.add_message(
+ create_cosmwasm_execute_msg(
+ wallet_address, contract, registration_msg, funds=f"{amount}{denom}"
+ )
+ )
+ elif not self.is_owner(name, domain, wallet_address):
  return None
 
- registration_msg = {
- "register": {
+ record_msg = {
+ "update_record": {
  "domain": f"{name}.{domain}",
- "agent_address": agent_address,
+ "agent_records": agent_records,
  }
  }
 
- contract = (
- TESTNET_CONTRACT_NAME_SERVICE if test else MAINNET_CONTRACT_NAME_SERVICE
- )
- transaction = Transaction()
  transaction.add_message(
- create_cosmwasm_execute_msg(wallet_address, contract, registration_msg)
+ create_cosmwasm_execute_msg(wallet_address, contract, record_msg)
  )
 
  return transaction
@@ -396,9 +453,10 @@ async def register(
  self,
  ledger: LedgerClient,
  wallet: LocalWallet,
- agent_address: str,
+ agent_records: Optional[Union[str, List[str], Dict[str, dict]]],
  name: str,
  domain: str,
+ overwrite: bool = True,
  ):
  """
  Register a name within a domain using the NameService contract.
@@ -409,28 +467,46 @@ async def register(
  agent_address (str): The address of the agent.
  name (str): The name to be registered.
  domain (str): The domain in which the name is registered.
+ overwrite (bool, optional): Specifies whether to overwrite any existing
+ addresses registered to the domain. If False, the address will be
+ appended to the previous records. Defaults to True.
  """
  logger.info("Registering name...")
  chain_id = ledger.query_chain_id()
 
- if not get_almanac_contract(chain_id == "dorado-1").is_registered(
- agent_address
- ):
- logger.warning(
- f"Agent {name} needs to be registered in almanac contract to register its name"
- )
- return
+ records = parse_record_config(agent_records)
+ agent_addresses = [val.get("address") for val in records]
+
+ for agent_address in agent_addresses:
+ if not get_almanac_contract(chain_id == "dorado-1").is_registered(
+ agent_address
+ ):
+ logger.warning(
+ "Address %s needs to be registered in almanac contract "
+ "to be registered in a domain",
+ agent_address,
+ )
+ return
 
  if not self.is_domain_public(domain):
  logger.warning(
  f"Domain {domain} is not public, please select a public domain"
  )
  return
 
+ if not overwrite:
+ previous_records = self.get_previous_records(name, domain)
+ records = list(
+ {
+ f"{rec['address']}_{rec['weight']}": rec
+ for rec in previous_records + records
+ }.values()
+ )
+
  transaction = self.get_registration_tx(
  name,
  str(wallet.address()),
- agent_address,
+ records,
  domain,
  chain_id == "dorado-1",
  )

python/src/uagents/resolver.py

@@ -129,9 +129,15 @@ def get_agent_address(name: str, test: bool) -> str:
  query_msg = {"domain_record": {"domain": f"{name}"}}
  result = get_name_service_contract(test).query(query_msg)
  if result["record"] is not None:
- registered_address = result["record"]["records"][0]["agent_address"]["records"]
- if len(registered_address) > 0:
- return registered_address[0]["address"]
+ registered_records = result["record"]["records"][0]["agent_address"]["records"]
+ if len(registered_records) > 0:
+ addresses = [val.get("address") for val in registered_records]
+ weights = [val.get("weight") for val in registered_records]
+ selected_address_list = weighted_random_sample(addresses, weights=weights)
+ selected_address = (
+ selected_address_list[0] if selected_address_list else None
+ )
+ return selected_address
  return None