Fixes iotaledger#288 Remove tips from get_inclusion_states

- `tips` parameter is no longer in use from IRI 1.9.0.
- GetInclusionStates API endpoint returns if tx is confirmed
  since the last milestone.
- `get_latest_iclusion_states` extended API becomes irrelevant,
  remove in this commit.
- Modify components using it, rely on `get_inclusion_states`.
- Update tests.
- Update documentation.

Author: lzpap

docs/extended_api.rst

@@ -30,10 +30,6 @@ tasks such as sending and receiving transfers.
 --------------
 .. automethod:: Iota.get_inputs
 
-``get_latest_inclusion``
-------------------------
-.. automethod:: Iota.get_latest_inclusion
-
 ``get_new_addresses``
 ---------------------
 .. automethod:: Iota.get_new_addresses

iota/api.py

@@ -384,22 +384,17 @@ def get_balances(
             tips=tips,
         )
 
-    def get_inclusion_states(self, transactions, tips):
-        # type: (Iterable[TransactionHash], Iterable[TransactionHash]) -> dict
+    def get_inclusion_states(self, transactions):
+        # type: (Iterable[TransactionHash]) -> dict
         """
         Get the inclusion states of a set of transactions. This is for
         determining if a transaction was accepted and confirmed by the
-        network or not. You can search for multiple tips (and thus,
-        milestones) to get past inclusion states of transactions.
+        network or not.
 
         :param Iterable[TransactionHash] transactions:
             List of transactions you want to get the inclusion state
             for.
 
-        :param Iterable[TransactionHash] tips:
-            List of tips (including milestones) you want to search for
-            the inclusion state.
-
         :return:
             ``dict`` with the following structure::
 
@@ -418,7 +413,6 @@ def get_inclusion_states(self, transactions, tips):
         """
         return core.GetInclusionStatesCommand(self.adapter)(
             transactions=transactions,
-            tips=tips,
         )
 
     def get_missing_transactions(self):
@@ -1123,30 +1117,6 @@ def get_inputs(
             securityLevel=security_level
         )
 
-    def get_latest_inclusion(self, hashes):
-        # type: (Iterable[TransactionHash]) -> Dict[TransactionHash, bool]
-        """
-        Fetches the inclusion state for the specified transaction
-        hashes, as of the latest milestone that the node has processed.
-
-        Effectively, this is :py:meth:`get_node_info` +
-        :py:meth:`get_inclusion_states`.
-
-        :param Iterable[TransactionHash] hashes:
-            List of transaction hashes.
-
-        :return:
-            ``dict`` with the following structure::
-
-                {
-                    "states": Dict[TransactionHash, bool]
-                        ``dict`` with one boolean per transaction hash in
-                        ``hashes``.
-                }
-
-        """
-        return extended.GetLatestInclusionCommand(self.adapter)(hashes=hashes)
-
     def get_new_addresses(
             self,
             index=0,

iota/commands/core/get_inclusion_states.py

@@ -35,14 +35,5 @@ def __init__(self):
                 # Required parameters.
                 'transactions':
                     StringifiedTrytesArray(TransactionHash) | f.Required,
-
-                # Optional parameters.
-                'tips':
-                    StringifiedTrytesArray(TransactionHash) |
-                    f.Optional(default=[]),
-            },
-
-            allow_missing_keys={
-                'tips',
             },
         )

iota/commands/extended/__init__.py

@@ -17,7 +17,6 @@
 from .get_account_data import *
 from .get_bundles import *
 from .get_inputs import *
-from .get_latest_inclusion import *
 from .get_new_addresses import *
 from .get_transaction_objects import *
 from .get_transfers import *

iota/commands/extended/get_latest_inclusion.py

@@ -8,8 +8,8 @@
 
 from iota import Address
 from iota.commands import FilterCommand, RequestFilter, ResponseFilter
-from iota.commands.extended import FindTransactionObjectsCommand, \
-    GetLatestInclusionCommand
+from iota.commands.extended import FindTransactionObjectsCommand
+from iota.commands.core import GetInclusionStatesCommand
 from iota.filters import Trytes, StringifiedTrytesArray
 
 __all__ = [
@@ -52,14 +52,15 @@ def _execute(self, request):
         }
 
         # Fetch inclusion states.
-        inclusion_states = GetLatestInclusionCommand(adapter=self.adapter)(
-            hashes=list(transaction_map.values()),
+        inclusion_states = GetInclusionStatesCommand(adapter=self.adapter)(
+            transactions=list(transaction_map.values()),
         )
-        inclusion_states = inclusion_states['states']
+        inclusion_states_map = dict(zip(
+            list(transaction_map.keys()), inclusion_states['states']))
 
         return {
             'reattachable': [
-                not inclusion_states[transaction_map[address]]
+                not inclusion_states_map[address]
                 for address in addresses
             ],
         }

iota/commands/extended/is_reattachable.py

@@ -13,8 +13,8 @@
     WereAddressesSpentFromCommand
 from iota.commands.extended import FindTransactionObjectsCommand
 from iota.commands.extended.get_bundles import GetBundlesCommand
-from iota.commands.extended.get_latest_inclusion import \
-    GetLatestInclusionCommand
+from iota.commands.core.get_inclusion_states import \
+    GetInclusionStatesCommand
 from iota.crypto.addresses import AddressGenerator
 from iota.crypto.types import Seed
 
@@ -109,12 +109,12 @@ def get_bundles_from_transaction_hashes(
 
     # Attach inclusion states, if requested.
     if inclusion_states:
-        gli_response = GetLatestInclusionCommand(adapter)(
-            hashes=list(tail_transaction_hashes),
+        gli_response = GetInclusionStatesCommand(adapter)(
+            transactions=list(tail_transaction_hashes),
         )
 
-        for txn in tail_transactions:
-            txn.is_confirmed = gli_response['states'].get(txn.hash)
+        for txn, state in zip(tail_transactions, gli_response['states']):
+            txn.is_confirmed = state
 
     # Find the bundles for each transaction.
     for txn in tail_transactions:

iota/commands/extended/utils.py

@@ -39,36 +39,13 @@ def test_pass_happy_path(self):
     request = {
       # Raw trytes are extracted to match the IRI's JSON protocol.
       'transactions': [self.trytes1, self.trytes2],
-
-      # These values would normally be different from
-      # ``transactions``, but for purposes of this unit test, we just
-      # need to make sure the format is correct.
-      'tips': [self.trytes1, self.trytes2],
     }
 
     filter_ = self._filter(request)
 
     self.assertFilterPasses(filter_)
     self.assertDictEqual(filter_.cleaned_data, request)
 
-  def test_pass_optional_parameters_omitted(self):
-    """
-    The request omits optional parameters.
-    """
-    filter_ = self._filter({
-      'transactions': [self.trytes1, self.trytes2],
-    })
-
-    self.assertFilterPasses(filter_)
-    self.assertDictEqual(
-      filter_.cleaned_data,
-
-      {
-        'tips':         [],
-        'transactions': [self.trytes1, self.trytes2],
-      },
-    )
-
   def test_pass_compatible_types(self):
     """
     The request contains values that can be converted to expected
@@ -79,19 +56,13 @@ def test_pass_compatible_types(self):
         TransactionHash(self.trytes1),
         bytearray(self.trytes2.encode('ascii')),
       ],
-
-      'tips': [
-        TransactionHash(self.trytes1),
-        bytearray(self.trytes2.encode('ascii')),
-      ],
     })
 
     self.assertFilterPasses(filter_)
     self.assertDictEqual(
       filter_.cleaned_data,
 
       {
-        'tips':         [self.trytes1, self.trytes2],
         'transactions': [self.trytes1, self.trytes2],
       },
     )
@@ -116,12 +87,12 @@ def test_fail_unexpected_parameters(self):
       {
         'transactions': [TransactionHash(self.trytes1)],
 
-        # I bring scientists, you bring a rock star.
-        'foo': 'bar',
+        # 'tips' deprecated in IRI 1.9.0
+        'tips': [self.trytes1]
       },
 
       {
-        'foo': [f.FilterMapper.CODE_EXTRA_KEY],
+        'tips': [f.FilterMapper.CODE_EXTRA_KEY],
       },
     )
 
@@ -201,62 +172,18 @@ def test_fail_transactions_contents_invalid(self):
       },
     )
 
-  def test_fail_tips_wrong_type(self):
-    """
-    ``tips`` is not an array.
-    """
-    self.assertFilterErrors(
-      {
-        'tips': TransactionHash(self.trytes2),
-
-        'transactions': [TransactionHash(self.trytes1)],
-      },
-
-      {
-        'tips': [f.Type.CODE_WRONG_TYPE],
-      },
-    )
-
-  def test_fail_tips_contents_invalid(self):
-    """
-    ``tips`` contains invalid values.
-    """
-    self.assertFilterErrors(
-      {
-        'tips': [
-          b'',
-          True,
-          None,
-          b'not valid trytes',
-
-          # This is actually valid; I just added it to make sure the
-          # filter isn't cheating!
-          TryteString(self.trytes1),
-
-          2130706433,
-          b'9' * 82,
-        ],
-
-        'transactions': [TransactionHash(self.trytes1)],
-      },
-
-      {
-        'tips.0':  [f.Required.CODE_EMPTY],
-        'tips.1':  [f.Type.CODE_WRONG_TYPE],
-        'tips.2':  [f.Required.CODE_EMPTY],
-        'tips.3':  [Trytes.CODE_NOT_TRYTES],
-        'tips.5':  [f.Type.CODE_WRONG_TYPE],
-        'tips.6':  [Trytes.CODE_WRONG_FORMAT],
-      },
-    )
-
 
 class GetInclusionStatesCommandTestCase(TestCase):
   def setUp(self):
     super(GetInclusionStatesCommandTestCase, self).setUp()
 
     self.adapter = MockAdapter()
 
+    self.trytes1 = (
+      'TESTVALUE9DONTUSEINPRODUCTION99999GCXWZZ'
+      'ZKNRIZENRRXGPAGJOSSWQQOJDD9VGQRMEFCOIFLQB'
+    )
+
   def test_wireup(self):
     """
     Verify that the command is wired up correctly.
@@ -270,11 +197,25 @@ def test_wireup(self):
       api = Iota(self.adapter)
 
       # Don't need to call with proper args here.
-      response = api.get_inclusion_states('transactions', 'tips')
+      response = api.get_inclusion_states('transactions')
 
       self.assertTrue(mocked_command.called)
 
       self.assertEqual(
         response,
         'You found me!'
       )
+
+  def test_fail_on_tips(self):
+    """
+    Fail on provided 'tips' parameter.
+
+    Dperecated in IRI 1.9.0
+    """
+    api = Iota(self.adapter)
+
+    with self.assertRaises(TypeError):
+      response = api.get_inclusion_states(
+        transactions=[self.trytes1],
+        tips=[self.trytes1]
+      )