[WIP] PrivateKey backed by cryptography

bitforge/__init__.py

@@ -1,10 +1,14 @@
+from network import Network
 from privkey import PrivateKey
 from pubkey import PublicKey
-from address import Address
-from script import Script
-from hdprivkey import HDPrivateKey
-from network import Network
-import network
-import ecdsa
+# from address import Address
+# from script import Script
+# from hdprivkey import HDPrivateKey
 from unit import Unit
-from uri import URI
+# from uri import URI
+
+import network
+import privkey
+import pubkey
+import unit
+# import uri

bitforge/encoding.py

@@ -1,68 +1,67 @@
-import utils, binascii, hashlib
-from errors import StringError
+import binascii
+import hashlib
 
+from bitforge import error
+from bitforge.utils import encoding
 
-class EncodingError(StringError):
-    "The string {string} is not properly encoded"
 
+class Error(error.BitforgeError):
+    pass
 
-class InvalidBase58h(EncodingError):
-    "The string {string} is not valid base58/check"
 
+def b2a_hex(data):
+    """Convert a byte buffer to an hexadecimal string."""
 
-class InvalidHex(EncodingError):
-    "The string {string} is not valid hexadecimal"
+    return binascii.b2a_hex(data)
 
 
-def encode_base58h(bytes):
-    return utils.encoding.b2a_hashed_base58(bytes)
+def a2b_hex(string):
+    """Convert an hexadecimal string to a byte buffer."""
 
+    if len(string) % 2 == 1:
+        string = '0' + string
 
-def decode_base58h(string):
     try:
-        return utils.encoding.a2b_hashed_base58(string)
+        return binascii.a2b_hex(string.encode('ascii'))
+    except TypeError:
+        raise Error('Invalid hexadecimal string')
 
-    except utils.encoding.EncodingError:
-        raise InvalidBase58h(string)
 
+def b2i_bigendian(data):
+    """Convert a big endian byte buffer to an unsigned big integer."""
 
-def encode_int(integer, big_endian = True):
-    bytes = bytearray()
+    # Encoding and decoding from hexa appears to be way faster than manually
+    # decoding the buffer in python.
+    return int(b2a_hex(data), 16)
 
-    while integer > 0:
-        bytes.append(integer & 0xff)
-        integer >>= 8
 
-    if big_endian:
-        bytes.reverse()
+def i2b_bigendian(number, num_bytes = 0):
+    """Convert an unsigned big integer to a zero-padded big endian byte buffer.
+    """
 
-    return str(bytes)
+    # Encoding and decoding from hexa appears to be way faster than manually
+    # decoding the buffer in python.
+    return a2b_hex('%0*x' % (2 * num_bytes, number))
 
 
-def decode_int(bytes, big_endian = True):
-    if not big_endian:
-        bytes = reversed(bytes)
+# TODO: implement these functions
 
-    integer = 0
+def b2a_base58check(data):
+    """Convert a byte buffer to a base58check string."""
 
-    for char in bytes:
-        integer <<= 8
-        integer += ord(char)
+    return encoding.b2a_hashed_base58(data)
 
-    return integer
 
+def a2b_base58check(string):
+    """Convert a base58check string to a byte buffer."""
 
-def encode_hex(bytes):
-    return binascii.hexlify(bytes)
-
-
-def decode_hex(string):
     try:
-        return binascii.unhexlify(string)
-    except:
-        # unhexlify() throws 2 different exceptions (length, and alphabet)
-        raise InvalidHex(string)
+        return encoding.a2b_hashed_base58(string)
+    except encoding.EncodingError:
+        raise Error('Invalid base58check string')
+
 
+# TODO: these are not encodings, they shouldn't be here
 
 def sha256(bytes):
     return hashlib.sha256(bytes).digest()

bitforge/error.py

@@ -1,34 +1,39 @@
-
 class BitforgeError(Exception):
+
     def __init__(self, *args, **kwargs):
         self.cause = kwargs.pop('cause', None)
         self.prepare(*args, **kwargs)
         self.message = self.__doc__.format(**self.__dict__)
 
-    def prepare(self):
-        pass
+    def prepare(self, message=None):
+        if message is not None:
+            self.__doc__ = message
 
     def __str__(self):
         return self.message
 
 
 class ObjectError(BitforgeError):
+
     def prepare(self, object):
         self.object = object
 
 
 class StringError(BitforgeError):
+
     def prepare(self, string):
         self.string = repr(string)
         self.length = len(string)
 
 
 class NumberError(BitforgeError):
+
     def prepare(self, number):
         self.number = number
 
 
 class KeyValueError(BitforgeError):
+
     def prepare(self, key, value):
         self.key   = key
         self.value = value

bitforge/network.py

@@ -29,6 +29,7 @@ class InvalidField(Error, error.StringError):
     'aliases',  # All the network aliases
 
     # Cryptography parameters
+    # WARNING: only curves over prime fields are currently supported
     'curve',  # Elliptic curve used for the crypto
     'hash_function',  # Signature hashing function
 
@@ -90,6 +91,8 @@ def __new__(cls, **kwargs):
                 if getattr(other, field) == getattr(network, field):
                     raise InvalidNetwork(field, getattr(network, field))
 
+        cls._networks.append(network)
+
         # Enforce uniqueness of the network aliases
         for name in [network.name] + network.aliases:
             if name in cls._networks_by_name:
@@ -108,7 +111,7 @@ def __str__(self):
 testnet = Network(
     name = 'testnet',
     aliases = [],
-    curve = ec.SECP256K1,
+    curve = ec.SECP256K1(),
     hash_function = hashes.SHA256,
     pubkeyhash = 111,
     wif_prefix = 239,
@@ -129,7 +132,7 @@ def __str__(self):
 default = livenet = Network(
     name = 'livenet',
     aliases = ['mainnet', 'default'],
-    curve = ec.SECP256K1,
+    curve = ec.SECP256K1(),
     hash_function = hashes.SHA256,
     pubkeyhash = 0x00,
     wif_prefix = 0x80,

bitforge/opcode.py

@@ -1,6 +1,7 @@
-import sys, inspect
-from numbers import Number
-from errors import *
+import sys
+import inspect
+
+from bitforge import error
 
 
 # Below is a list of all *named* opcodes. Their values, integers in the
@@ -155,28 +156,26 @@
 
 class Opcode(object):
 
-    class Error(BitforgeError):
+    class Error(error.BitforgeError):
         pass
 
-    class UnknownOpcodeName(Error, StringError):
+    class UnknownOpcodeName(Error, error.StringError):
         "No known operation named {string}"
 
-    class UnknownOpcodeNumber(Error, NumberError):
+    class UnknownOpcodeNumber(Error, error.NumberError):
         "No known operation numbered {number}"
 
-    class InvalidConstPushLength(Error, StringError):
+    class InvalidConstPushLength(Error, error.StringError):
         "No constant push opcode can push {length} bytes (only [1-75])"
 
-    class InvalidPushLength(Error, NumberError):
+    class InvalidPushLength(Error, error.NumberError):
         "No Opcode can push {number} bytes"
 
-    class TypeError(Error, ObjectError):
+    class TypeError(Error, error.ObjectError):
         "Opcodes are initialized from numbers and names, got object {object}"
 
-
     opcode_number_to_name = {}  # Filled after class definition
 
-
     def __init__(self, number):
         if not (0 <= number <= 255):
             raise Opcode.UnknownOpcodeNumber(number)
@@ -218,7 +217,6 @@ def __eq__(self, other):
     def __hash__(self):
         return hash(self.number)
 
-
     @staticmethod
     def for_number(n):
         if 0 <= n <= 16:
@@ -243,13 +241,13 @@ def const_push_for(length):
     @staticmethod
     def var_push_for(length):
         if length < 1:
-            raise InvalidPushLength(length)
+            raise Opcode.InvalidPushLength(length)
 
         for opcode in [OP_PUSHDATA1, OP_PUSHDATA2, OP_PUSHDATA4]:
             if length <= Opcode.data_length_max(opcode):
                 return opcode
 
-        raise InvalidPushLength(length)
+        raise Opcode.InvalidPushLength(length)
 
     @staticmethod
     def push_for(length):
@@ -282,7 +280,6 @@ def data_length_nbytes(opcode):
         }[opcode]
 
 
-
 # Walk the OP_* variables, mapping them to their names and creating Opcode objs:
 _module = sys.modules[__name__]
 
@@ -294,7 +291,7 @@ def data_length_nbytes(opcode):
         # Replace integer values with actual Opcode instances:
         setattr(_module, name, Opcode(number))
 
-Opcode.opcode_number_to_name[OP_0] = 'OP_0' # shares number with OP_FALSE
-Opcode.opcode_number_to_name[OP_1] = 'OP_1' # shares number with OP_TRUE
+Opcode.opcode_number_to_name[OP_0] = 'OP_0'  # shares number with OP_FALSE
+Opcode.opcode_number_to_name[OP_1] = 'OP_1'  # shares number with OP_TRUE
 
-del _module # the expected use for this module is to import *
+del _module   # the expected use for this module is to import *