cleanup account name registry

Author: billbsing

CHANGELOG.md

@@ -1,5 +1,8 @@
 ## Change log
 
+### 0.1.2
++   Improve registration of account names and resolving account names from the CNS registry
+
 ### 0.1.1
 +   Incease minimum topup_account funds to 10,000,000
 +   Allow to register and load accounts using a name

convex_api/convex_api.py

@@ -153,7 +153,7 @@ def load_account(self, name, account):
             new_account = Account.import_from_account(account, address=address, name=name)
             return new_account
 
-    def setup_account(self, name, import_account):
+    def setup_account(self, name, import_account, register_account=None):
         """
 
         Convenience method to create or load an account based on the account name.
@@ -162,10 +162,12 @@ def setup_account(self, name, import_account):
 
         :param str name: name of the account to create or load
         :param Account account: :class:`.Account` object to import
+        :param Account register_account: Optional :class:`.Account` object to use for registration of the account
 
         :results: :class:`.Account` object with the address and name set, if not found then return None
 
-        **Note** This method calls the :meth:`.topup_account` method to get enougth funds to register an account name.
+        **Note** If you do not provide a register_account, then this method calls the
+        :meth:`.topup_account` method to get enougth funds to register an account name.
 
 
         .. code-block:: python
@@ -177,41 +179,73 @@ def setup_account(self, name, import_account):
             my_account
 
         """
+
+        # check to see if we can resolve the account name
         if self.resolve_account_name(name):
+            # if so just load the account
             account = self.load_account(name, import_account)
         else:
+            # new name , so first create the account
             account = self.create_account(account=import_account)
-            self.topup_account(account)
-            self.register_account_name(name, account)
-        self.topup_account(account)
+            if not register_account:
+                # make sure we have enougth funds to do the registration
+                self.topup_account(account)
+                register_account = account
+            account = self.register_account_name(name, account, register_account)
         return account
 
-    def register_account_name(self, name, account):
+    def register_account_name(self, name, address_account, account=None):
         """
 
-        Register an account address with an account name.
+        Register or update an account address with an account name.
 
         This call will submit to the CNS (Convex Name Service), a name in the format
         "`account.<your_name>`". You need to have some convex balance in your account, and
         a valid account address.
 
-        :param str name: name of the account to register
-        :param Account account: :class:`.Account` object to register the account name
+        :param str name: name of the account to register.
+        :param number|Account account_address: Account or address to register.
+        :param Account account: :class:`.Account` object to register the account name.
+
+        .. code-block:: python
 
+            >>> # load the register account
+            >>> register_account = convex.load_account('register_account', import_account)
+            >>> account = convex.create_account(import_account)
+            >>> print(account.address)
+            1024
+            >>> account = convex.register_account('my_new_account', account.address, register_account)
+            >>> print(account.address)
+            1024
 
-        >>> # create a new account
-        >>> account = convex.create_account()
-        >>> # add some convex tokens to the account
-        >>> convex.topup_account(account)
-        10000000
-        >>> account = convex.register_account('my_new_account', account)
-        >>> print(account.name)
-        my_new_account
+            # or you can call with only one account, this will use the address of that account
+            >>> print(register_account.address)
+            404
+            >>> account = convex.register_account('my_new_account', register_account)
+            >>> print(account.address)
+            404
 
         """
-        if account.address:
-            self._registry.register(f'account.{name}', account.address, account)
-            return Account.import_from_account(account, address=account.address, name=name)
+
+        # is the address_account field only an address?
+        if is_address(address_account):
+            address = to_address(address_account)
+        else:
+            # if account then use the account address, and also see if we can use it for the
+            # registration
+            address = address_account.address
+            if account is None:
+                account = address_account
+
+        # we must have a valid account to do the registration
+        if not account:
+            raise ValueError('you need to provide a registration account to register an account name')
+
+        if not address:
+            raise ValueError('You need to provide a valid address to register an account name')
+
+        self._registry.register(f'account.{name}', address, account)
+        return Account.import_from_account(account, address=address, name=name)
 
     def send(self, transaction, account, language=None, sequence_retry_count=20):
         """
@@ -551,9 +585,6 @@ def get_account_info(self, address_account):
             'isLibrary': False, 'isActor': False, 'allowance': 0,
             'sequence': 0, 'type': 'user'}
 
-
-
-
         """
         if is_address(address_account):
             address = to_address(address_account)
@@ -572,8 +603,31 @@ def get_account_info(self, address_account):
         return result
 
     def resolve_account_name(self, name):
+        """
+        Resolves an account name to an address.
+        :param string name Name of the account to resolve.
+
+        .. code-block:: python
+
+            >>> convex.resolve_account_name('my_account')
+            405
+
+        """
         return self._registry.resolve_address(f'account.{name}')
 
+    def resolve_name(self, name):
+        """
+        Resolves any Convex Name Services to an address.
+        :param string name Name of the the CNS Service.
+
+        .. code-block:: python
+
+            >>> convex.resolve_account_name('convex.nft-tokens')
+            25
+
+        """
+        return self._registry.resolve_address(name)
+
     def _transaction_prepare(self, address, transaction, language=None, sequence_number=None):
         """
 
@@ -654,3 +708,7 @@ def language(self):
 
         """
         return self._language
+
+    @property
+    def registry(self):
+        return self._registry

tests/conftest.py

@@ -43,14 +43,12 @@ def test_account_info():
     }
 
 @pytest.fixture(scope='module')
-def test_account(convex, test_account_info):
-    import_account = Account.import_from_bytes(test_account_info['private_bytes'])
-    if convex.resolve_account_name(TEST_ACCOUNT_NAME):
-        account = convex.load_account(TEST_ACCOUNT_NAME, import_account)
-    else:
-        account = convex.create_account(account=import_account)
-        convex.topup_account(account)
-        convex.register_account_name(TEST_ACCOUNT_NAME, account)
+def import_account(test_account_info):
+    return Account.import_from_bytes(test_account_info['private_bytes'])
+
+@pytest.fixture(scope='module')
+def test_account(convex, import_account):
+    account = convex.setup_account(TEST_ACCOUNT_NAME, import_account)
     convex.topup_account(account)
     return account
 

tests/intergration/test_convex_api.py

@@ -72,6 +72,39 @@ def test_convex_get_account_info(convex_url, test_account):
     assert(info)
     assert(info['balance'] == TEST_FUNDING_AMOUNT)
 
+def test_convex_account_name_registry(convex_url, test_account, import_account):
+    account_name = f'test.convex-api.{secrets.token_hex(4)}'
+    convex = ConvexAPI(convex_url)
+
+    address = convex.resolve_account_name(account_name)
+    assert(not address)
+
+    account = convex.load_account(account_name, import_account)
+    assert(not account)
+
+
+    register_account = convex.register_account_name(account_name, test_account)
+    assert(register_account.address == test_account.address)
+
+    assert(convex.resolve_account_name(account_name) == test_account.address)
+
+    new_account = convex.create_account(import_account)
+    register_account = convex.register_account_name(account_name, new_account, test_account)
+
+    assert(register_account.address == new_account.address)
+    assert(convex.resolve_account_name(account_name) == new_account.address)
+
+    # clear the cache in the registry
+    convex.registry.clear()
+    assert(convex.resolve_account_name(account_name) == new_account.address)
+
+
+def test_convex_resolve_name(convex_url):
+    convex = ConvexAPI(convex_url)
+    address = convex.resolve_name('convex.nft-tokens')
+    assert(address)
+
+
 def test_convex_api_send_basic_lisp(convex_url, test_account):
     convex = ConvexAPI(convex_url)
     request_amount = convex.request_funds(TEST_FUNDING_AMOUNT, test_account)