Change Optional[bool] to just bool, alphabetical string ordering, use AddressGenerator.DEFAULT_SECURITY_LEVEL instead of hardcoded 2 in example, use addy.address for checksum-less address

Author: plenarius

examples/address_generator.py

@@ -12,12 +12,13 @@
 from typing import Optional, Text
 
 from iota import __version__, Iota
+from iota.crypto.addresses import AddressGenerator
 from iota.crypto.types import Seed
 from six import binary_type, moves as compat, text_type
 
 
 def main(uri, index, count, security, checksum):
-  # type: (Text, int, Optional[int], Optional[int], Optional[bool]) -> None
+  # type: (Text, int, Optional[int], Optional[int], bool) -> None
   seed = get_seed()
 
   # Create the API instance.
@@ -114,8 +115,9 @@ def output_seed(seed):
   parser.add_argument(
     '--security',
       type      = int,
-      default   = 2,
-      help      = 'Security level to be used for the private key / address. Can be 1, 2 or 3',
+      default   = AddressGenerator.DEFAULT_SECURITY_LEVEL,
+      help      = 'Security level to be used for the private key / address. '
+                  'Can be 1, 2 or 3',
   )
 
   parser.add_argument(

iota/api.py

@@ -613,7 +613,7 @@ def get_new_addresses(
       security_level = AddressGenerator.DEFAULT_SECURITY_LEVEL,
       checksum = False,
   ):
-    # type: (int, Optional[int], int, Optional[bool]) -> dict
+    # type: (int, Optional[int], int, bool) -> dict
     """
     Generates one or more new addresses from the seed.
 

iota/commands/extended/get_new_addresses.py

@@ -33,10 +33,10 @@ def get_response_filter(self):
     pass
 
   def _execute(self, request):
+    checksum        = request['checksum'] # type: bool
     count           = request['count'] # type: Optional[int]
     index           = request['index'] # type: int
     security_level  = request['securityLevel'] # type: int
-    checksum        = request['checksum'] # type: Optional[bool]
     seed            = request['seed'] # type: Seed
 
     return {
@@ -45,27 +45,22 @@ def _execute(self, request):
     }
 
   def _find_addresses(self, seed, index, count, security_level, checksum):
-    # type: (Seed, int, Optional[int], int, Optional[bool]) -> List[Address]
+    # type: (Seed, int, Optional[int], int, bool) -> List[Address]
     """
     Find addresses matching the command parameters.
     """
-    # type: (Seed, int, Optional[bool]) -> List[Address]
     generator = AddressGenerator(seed, security_level, checksum)
 
     if count is None:
       # Connect to Tangle and find the first address without any
       # transactions.
       for addy in generator.create_iterator(start=index):
-        # If we're generating addresses with checksums we need to check
-        # for transactions on the address without the checksum
-        if not checksum:
-          response = FindTransactionsCommand(self.adapter)(addresses=[addy])
-        else:
-          response = FindTransactionsCommand(self.adapter)(
-            addresses=[addy][:-AddressChecksum.LEN]
+        # We use addy.address here because FindTransactions does
+        # not work on an address with a checksum
+        response = FindTransactionsCommand(self.adapter)(
+           addresses=[addy.address]
         )
 
-
         if not response.get('hashes'):
           return [addy]
 
@@ -85,24 +80,24 @@ def __init__(self):
     super(GetNewAddressesRequestFilter, self).__init__(
       {
         # Everything except ``seed`` is optional.
-        'count':  f.Type(int) | f.Min(1),
-        'index':  f.Type(int) | f.Min(0) | f.Optional(default=0),
+
+        'checksum':  f.Type(bool) | f.Optional(default=False),
+        'count':     f.Type(int) | f.Min(1),
+        'index':     f.Type(int) | f.Min(0) | f.Optional(default=0),
 
         'securityLevel':
               f.Type(int)
             | f.Min(1)
             | f.Max(self.MAX_SECURITY_LEVEL)
             | f.Optional(default=AddressGenerator.DEFAULT_SECURITY_LEVEL),
 
-        'checksum':  f.Type(bool) | f.Optional(default=False),
-
         'seed': f.Required | Trytes(result_type=Seed),
       },
 
       allow_missing_keys = {
+        'checksum',
         'count',
         'index',
         'securityLevel',
-        'checksum',
       },
     )

test/commands/extended/get_new_addresses_test.py

@@ -482,10 +482,10 @@ def test_new_address_checksum(self):
     """
     response =\
       self.command(
+        checksum      = True,
         count         = 1,
         index         = 0,
         seed          = self.seed,
-        checksum      = True,
       )
 
     self.assertDictEqual(

test/crypto/addresses_test.py

@@ -279,3 +279,37 @@ def test_security_level_elevated(self):
         ),
       ],
     )
+
+  def test_generator_checksum(self):
+    """
+    Creating a generator with checksums on the addresses.
+    """
+    ag = AddressGenerator(
+       self.seed_2,
+       security_level=AddressGenerator.DEFAULT_SECURITY_LEVEL,
+       checksum=True
+    )
+
+    generator = ag.create_iterator()
+
+    # noinspection SpellCheckingInspection
+    self.assertEqual(
+      next(generator),
+
+      Address(
+        b'FNKCVJPUANHNWNBAHFBTCONMCUBC9KCZ9EKREBCJ'
+        b'AFMABCTEPLGGXDJXVGPXDCFOUCRBWFJFLEAVOEUPY'
+        b'ADHVCBXFD',
+      ),
+    )
+
+    # noinspection SpellCheckingInspection
+    self.assertEqual(
+      next(generator),
+
+      Address(
+        b'MSYILYYZLSJ99TDMGQHDOBWGHTBARCBGJZE9PIMQ'
+        b'LTEXJXKTDREGVTPA9NDGGLQHTMGISGRAKSLYPGWMB'
+        b'WIKQRCIOD',
+      ),
+    )