[#10] Minor reorg.

- Moved signature functionality into new `PrivateKey.sign_bundle_at` method.
- Split out `BundleValidator` into own module to avoid circular import.
- Renamed `iota.transaction.{read,write}` to `base` and `creation`, respectively.
- Removed some unit tests that would conflict with multisig (might add back later tho).

Author: todofixthis

iota/commands/extended/get_bundles.py

@@ -11,7 +11,7 @@
 from iota.commands.core.get_trytes import GetTrytesCommand
 from iota.exceptions import with_context
 from iota.filters import Trytes
-from iota.transaction import BundleValidator
+from iota.transaction.validator import BundleValidator
 
 __all__ = [
   'GetBundlesCommand',

iota/crypto/types.py

@@ -4,9 +4,10 @@
 
 from typing import MutableSequence, Optional, Tuple
 
-from iota import Hash, TryteString, TrytesCompatible
 from iota.crypto import Curl, FRAGMENT_LENGTH, HASH_LENGTH
 from iota.exceptions import with_context
+from iota.transaction.base import Bundle
+from iota.types import Hash, TryteString, TrytesCompatible
 
 __all__ = [
   'Digest',
@@ -179,3 +180,88 @@ def get_digest(self):
       digest[fragment_start:fragment_end] = hash_trits
 
     return Digest(TryteString.from_trits(digest), self.key_index)
+
+  def sign_bundle_at(self, bundle, start_index):
+    # type: (Bundle, int) -> None
+    """
+    Signs the input at the specified index.
+
+    :param start_index:
+      The index of the first input transaction.
+
+      If necessary, the resulting signature will be split across
+      subsequent transactions automatically.
+    """
+
+    if not bundle.hash:
+      raise with_context(
+        exc = ValueError('Cannot sign inputs without a bundle hash!'),
+
+        context = {
+          'bundle':       bundle,
+          'key_index':    self.key_index,
+          'start_index':  start_index,
+        },
+      )
+
+    from iota.crypto.signing import SignatureFragmentGenerator
+    signature_fragment_generator = SignatureFragmentGenerator(self, bundle.hash)
+
+    # We can only fit one signature fragment into each transaction,
+    # so we have to split the entire signature.
+    for j in range(self.security_level):
+      # Do lots of validation before we attempt to sign the
+      # transaction, and attach lots of context info to any exception.
+      # This method is likely to be invoked at a very low level in the
+      # application, so if anything goes wrong, we want to make sure
+      # it's as easy to troubleshoot as possible!
+      try:
+        txn = bundle[start_index+j]
+      except IndexError as e:
+        raise with_context(
+          exc = e,
+
+          context = {
+            'bundle':         bundle,
+            'key_index':      self.key_index,
+            'current_index':  start_index + j,
+          },
+        )
+
+      # Only inputs can be signed.
+      if txn.value > 0:
+        raise with_context(
+          exc =
+            ValueError(
+              'Attempting to sign non-input transaction #{i} '
+              '(value={value}).'.format(
+                i     = txn.current_index,
+                value = txn.value,
+              ),
+            ),
+
+          context = {
+            'bundle':       bundle,
+            'key_index':    self.key_index,
+            'start_index':  start_index,
+          },
+        )
+
+      if txn.signature_message_fragment:
+        raise with_context(
+          exc =
+            ValueError(
+              'Attempting to sign input transaction #{i}, '
+              'but it has a non-empty fragment (is it already signed?).'.format(
+                i = txn.current_index,
+              ),
+            ),
+
+          context = {
+            'bundle':       bundle,
+            'key_index':    self.key_index,
+            'start_index':  start_index,
+          },
+        )
+
+      txn.signature_message_fragment = next(signature_fragment_generator)

iota/transaction/__init__.py

@@ -2,8 +2,10 @@
 from __future__ import absolute_import, division, print_function, \
   unicode_literals
 
-# Import symbols for backwards-compatibility with PyOTA 1.1.x.
-from .read import *
+# Import symbols to package namespace, for backwards-compatibility with
+# PyOTA 1.1.x.
+from .base import *
+from .creation import *
 from .types import *
 from .utils import *
-from .write import *
+from .validator import *

iota/transaction/read.py renamed to iota/transaction/base.py

@@ -3,12 +3,11 @@
   unicode_literals
 
 from operator import attrgetter
-from typing import Generator, Iterable, Iterator, List, MutableSequence, \
-  Optional, Sequence, Text, Tuple
+from typing import Iterable, Iterator, List, MutableSequence, \
+  Optional, Sequence, Text
 
 from iota.codecs import TrytesDecodeError
 from iota.crypto import Curl, HASH_LENGTH
-from iota.crypto.signing import validate_signature_fragments
 from iota.json import JsonSerializable
 from iota.transaction.types import BundleHash, Fragment, TransactionHash, \
   TransactionTrytes
@@ -17,7 +16,6 @@
 
 __all__ = [
   'Bundle',
-  'BundleValidator',
   'Transaction',
 ]
 
@@ -482,158 +480,3 @@ def group_transactions(self):
     return groups
 
 
-class BundleValidator(object):
-  """
-  Checks a bundle and its transactions for problems.
-  """
-  def __init__(self, bundle):
-    # type: (Bundle) -> None
-    super(BundleValidator, self).__init__()
-
-    self.bundle = bundle
-
-    self._errors    = [] # type: Optional[List[Text]]
-    self._validator = self._create_validator()
-
-  @property
-  def errors(self):
-    # type: () -> List[Text]
-    """
-    Returns all errors found with the bundle.
-    """
-    try:
-      self._errors.extend(self._validator) # type: List[Text]
-    except StopIteration:
-      pass
-
-    return self._errors
-
-  def is_valid(self):
-    # type: () -> bool
-    """
-    Returns whether the bundle is valid.
-    """
-    if not self._errors:
-      try:
-        # We only have to check for a single error to determine if the
-        # bundle is valid or not.
-        self._errors.append(next(self._validator))
-      except StopIteration:
-        pass
-
-    return not self._errors
-
-  def _create_validator(self):
-    # type: () -> Generator[Text]
-    """
-    Creates a generator that does all the work.
-    """
-    # Group transactions by address to make it easier to iterate over
-    # inputs.
-    grouped_transactions = self.bundle.group_transactions()
-
-    # Define a few expected values.
-    bundle_hash = self.bundle.hash
-    last_index  = len(self.bundle) - 1
-
-    # Track a few others as we go along.
-    balance = 0
-
-    # Check indices and balance first.
-    # Note that we use a counter to keep track of the current index,
-    # since at this point we can't trust that the transactions have
-    # correct ``current_index`` values.
-    counter = 0
-    for group in grouped_transactions:
-      for txn in group:
-        balance += txn.value
-
-        if txn.bundle_hash != bundle_hash:
-          yield 'Transaction {i} has invalid bundle hash.'.format(
-            i = counter,
-          )
-
-        if txn.current_index != counter:
-          yield (
-            'Transaction {i} has invalid current index value '
-            '(expected {i}, actual {actual}).'.format(
-              actual  = txn.current_index,
-              i       = counter,
-            )
-          )
-
-        if txn.last_index != last_index:
-          yield (
-            'Transaction {i} has invalid last index value '
-            '(expected {expected}, actual {actual}).'.format(
-              actual    = txn.last_index,
-              expected  = last_index,
-              i         = counter,
-            )
-          )
-
-        counter += 1
-
-    # Bundle must be balanced (spends must match inputs).
-    if balance != 0:
-      yield (
-        'Bundle has invalid balance (expected 0, actual {actual}).'.format(
-          actual = balance,
-        )
-      )
-
-    # Signature validation is only meaningful if the transactions are
-    # otherwise valid.
-    if not self._errors:
-      for group in grouped_transactions:
-        # Signature validation only applies to inputs.
-        if group[0].value >= 0:
-          continue
-
-        signature_valid = True
-        signature_fragments = []
-        for j, txn in enumerate(group): # type: Tuple[int, Transaction]
-          if (j > 0) and (txn.value != 0):
-            # Input is malformed; signature fragments after the first
-            # should have zero value.
-            yield (
-              'Transaction {i} has invalid amount '
-              '(expected 0, actual {actual}).'.format(
-                actual = txn.value,
-
-                # If we get to this point, we know that the
-                # ``current_index`` value for each transaction can be
-                # trusted.
-                i = txn.current_index,
-              )
-            )
-
-            # We won't be able to validate the signature, but continue
-            # anyway, so that we can check that the other transactions
-            # in the group have the correct ``value``.
-            signature_valid = False
-            continue
-
-          signature_fragments.append(txn.signature_message_fragment)
-
-        # After collecting the signature fragment from each transaction
-        # in the group, run it through the validator.
-        if signature_valid:
-          signature_valid = validate_signature_fragments(
-            fragments   = signature_fragments,
-            hash_       = txn.bundle_hash,
-            public_key  = txn.address,
-          )
-
-          if not signature_valid:
-            yield (
-              'Transaction {i} has invalid signature '
-              '(using {fragments} fragments).'.format(
-                fragments = len(signature_fragments),
-
-                # If we get to this point, we know that the
-                # ``current_index`` value for each transaction can be
-                # trusted.
-                i = group[0].current_index,
-              )
-            )