diff --git a/pybtc/address.py b/pybtc/address.py
index 0828877..2f46a43 100644
--- a/pybtc/address.py
+++ b/pybtc/address.py
@@ -19,7 +19,7 @@ class PrivateKey():
                 self.testnet = testnet
                 return
             assert type(key) == str
-            self.raw_key = WIF_to_private_key(key)
+            self.raw_key = wif_to_private_key(key)
             if key[0] in (MAINNET_PRIVATE_KEY_UNCOMPRESSED_PREFIX,
                           TESTNET_PRIVATE_KEY_UNCOMPRESSED_PREFIX):
                 self.compressed = False
@@ -39,7 +39,7 @@ class PrivateKey():
             compressed = self.compressed
         if testnet is None:
             testnet = self.testnet
-        return private_key_to_WIF(self.raw_key, compressed, testnet)
+        return private_key_to_wif(self.raw_key, compressed, testnet)
 
 
 class PublicKey():
@@ -95,7 +95,7 @@ class Address():
 
         if address_type == "P2SH_P2WPKH":
             self.script_hash = True
-            self.redeem_script = public_key_to_P2SH_P2WPKH_script(self.public_key.raw_key)
+            self.redeem_script = public_key_to_p2sh_p2wpkh_script(self.public_key.raw_key)
             self.redeem_script_hex = hexlify(self.redeem_script).decode()
             self.hash = hash160(self.redeem_script)
         else:
diff --git a/pybtc/blockchain.py b/pybtc/blockchain.py
index c52f211..8f6fbd4 100644
--- a/pybtc/blockchain.py
+++ b/pybtc/blockchain.py
@@ -196,7 +196,7 @@ class OLDTransaction():
 
     def sign_P2SHP2WPKH_input(self, sighash_type, input_index, private_key = None, amount = None):
         if type(private_key) == str:
-            private_key = WIF_to_private_key(private_key)
+            private_key = wif_to_private_key(private_key)
         if amount is not None:
             self.tx_in[input_index].amount = amount
         else:
diff --git a/pybtc/constants.py b/pybtc/constants.py
index cdc508f..352906c 100644
--- a/pybtc/constants.py
+++ b/pybtc/constants.py
@@ -1,5 +1,4 @@
 from secp256k1 import lib as secp256k1
-from secp256k1 import ffi
 import random
 
 SIGHASH_ALL           = 0x00000001
diff --git a/pybtc/tools.py b/pybtc/tools.py
index dbed6bd..7993637 100644
--- a/pybtc/tools.py
+++ b/pybtc/tools.py
@@ -1,5 +1,6 @@
 import time
 import struct
+from secp256k1 import ffi
 from .constants import *
 from .opcodes import *
 from .hash import *
@@ -14,22 +15,24 @@ def create_private_key(hex=False):
     """
     :return: 32 bytes private key 
     """
-    a = random.SystemRandom().randint(0,MAX_INT_PRIVATE_KEY)
-    i = int((time.time()%0.01)*100000)
-    h = a.to_bytes(32,byteorder="big")
+    a = random.SystemRandom().randint(0, MAX_INT_PRIVATE_KEY)
+    i = int((time.time() % 0.01)*100000)
+    h = a.to_bytes(32, byteorder="big")
     while True:
         h = hashlib.sha256(h).digest()
-        if i>1: i -= 1
+        if i > 1:
+            i -= 1
         else:
-            if int.from_bytes(h,byteorder="big")<MAX_INT_PRIVATE_KEY:
+            if int.from_bytes(h, byteorder="big") < MAX_INT_PRIVATE_KEY:
                 break
     if hex:
         return hexlify(h).decode()
     return h
 
-def private_key_to_WIF(h, compressed = True, testnet = False):
-    #uncompressed: 0x80 + [32-byte secret] + [4 bytes of Hash() of previous 33 bytes], base58 encoded
-    #compressed: 0x80 + [32-byte secret] + 0x01 + [4 bytes of Hash() previous 34 bytes], base58 encoded
+
+def private_key_to_wif(h, compressed=True, testnet=False):
+    # uncompressed: 0x80 + [32-byte secret] + [4 bytes of Hash() of previous 33 bytes], base58 encoded
+    # compressed: 0x80 + [32-byte secret] + 0x01 + [4 bytes of Hash() previous 34 bytes], base58 encoded
     if type(h) == str:
         h = unhexlify(h)
     assert len(h) == 32
@@ -37,18 +40,21 @@ def private_key_to_WIF(h, compressed = True, testnet = False):
         h = TESTNET_PRIVATE_KEY_BYTE_PREFIX + h
     else:
         h = MAINNET_PRIVATE_KEY_BYTE_PREFIX + h
-    if compressed: h += b'\x01'
+    if compressed:
+        h += b'\x01'
     h += double_sha256(h)[:4]
     return encode_base58(h)
 
-def WIF_to_private_key(h, hex = False):
-    assert is_WIF_valid(h)
+
+def wif_to_private_key(h, hex=False):
+    assert is_wif_valid(h)
     h = decode_base58(h)
     if hex:
         return hexlify(h[1:33]).decode()
     return h[1:33]
 
-def is_WIF_valid(wif):
+
+def is_wif_valid(wif):
     assert type(wif) == str
     if wif[0] not in PRIVATE_KEY_PREFIX_LIST:
         return False
@@ -67,18 +73,19 @@ def is_WIF_valid(wif):
         return False
     return True
 
-def private_to_public_key(private_key, compressed = True, hex = False):
+
+def private_to_public_key(private_key, compressed=True, hex=False):
     if type(private_key)!= bytes:
         if type(private_key) == bytearray:
             private_key = bytes(private_key)
         elif type(private_key) == str:
-            if not is_WIF_valid(private_key):
+            if not is_wif_valid(private_key):
                 private_key = unhexlify(private_key)
             else:
                 if private_key[0] in (MAINNET_PRIVATE_KEY_UNCOMPRESSED_PREFIX,
                                       TESTNET_PRIVATE_KEY_UNCOMPRESSED_PREFIX):
                     compressed = False
-                private_key = WIF_to_private_key(private_key)
+                private_key = wif_to_private_key(private_key)
         else:
             raise TypeError("private key must be a bytes or WIF or hex encoded string")
     pubkey_ptr = ffi.new('secp256k1_pubkey *')
@@ -93,6 +100,7 @@ def private_to_public_key(private_key, compressed = True, hex = False):
     pub = bytes(ffi.buffer(pubkey, len_key))
     return hexlify(pub).decode() if hex else pub
 
+
 def is_valid_public_key(key):
     if len(key) < 33:
         return False
@@ -109,8 +117,8 @@ def is_valid_public_key(key):
 #
 
 
-def hash_to_address(address_hash, testnet = False,
-                    script_hash = False, witness_version = 0):
+def hash_to_address(address_hash, testnet=False,
+                    script_hash=False, witness_version=0):
     if type(address_hash) == str:
         address_hash = unhexlify(address_hash)
     if not script_hash:
@@ -120,7 +128,7 @@ def hash_to_address(address_hash, testnet = False,
                 prefix = TESTNET_ADDRESS_BYTE_PREFIX
             else:
                 prefix = MAINNET_ADDRESS_BYTE_PREFIX
-            address_hash =  prefix + address_hash
+            address_hash = prefix + address_hash
             address_hash += double_sha256(address_hash)[:4]
             return encode_base58(address_hash)
         else:
@@ -130,7 +138,7 @@ def hash_to_address(address_hash, testnet = False,
             prefix = TESTNET_SCRIPT_ADDRESS_BYTE_PREFIX
         else:
             prefix = MAINNET_SCRIPT_ADDRESS_BYTE_PREFIX
-        address_hash =  prefix + address_hash
+        address_hash = prefix + address_hash
         address_hash += double_sha256(address_hash)[:4]
         return encode_base58(address_hash)
     if testnet:
@@ -139,15 +147,15 @@ def hash_to_address(address_hash, testnet = False,
     else:
         prefix = MAINNET_SEGWIT_ADDRESS_BYTE_PREFIX
         hrp = MAINNET_SEGWIT_ADDRESS_PREFIX
-    address_hash = witness_version.to_bytes(1, "big") + rebase_8_to_5(  address_hash)
+    address_hash = witness_version.to_bytes(1, "big") + rebase_8_to_5(address_hash)
     checksum = bech32_polymod(prefix + address_hash + b"\x00" * 6)
     checksum = rebase_8_to_5(checksum.to_bytes(5, "big"))[2:]
     return "%s1%s" % (hrp, rebase_5_to_32(address_hash + checksum).decode())
 
 
-def address_to_hash(address, hex = False):
+def address_to_hash(address, hex=False):
     if address[0] in ADDRESS_PREFIX_LIST:
-        h =  decode_base58(address)[1:-4]
+        h = decode_base58(address)[1:-4]
     elif address[:2] in (MAINNET_SEGWIT_ADDRESS_PREFIX,
                          TESTNET_SEGWIT_ADDRESS_PREFIX):
         address = address.split("1")[1]
@@ -159,18 +167,20 @@ def address_to_hash(address, hex = False):
     else:
         return h
 
+
 def get_witness_version(address):
     address = address.split("1")[1]
     h = rebase_32_to_5(address)
     return h[0]
 
-def address_type(address, num = False):
+
+def address_type(address, num=False):
     if address[0] in (TESTNET_SCRIPT_ADDRESS_PREFIX,
                       MAINNET_SCRIPT_ADDRESS_PREFIX):
         t = 'P2SH'
     elif address[0] in (MAINNET_ADDRESS_PREFIX,
-                      TESTNET_ADDRESS_PREFIX,
-                      TESTNET_ADDRESS_PREFIX_2):
+                        TESTNET_ADDRESS_PREFIX,
+                        TESTNET_ADDRESS_PREFIX_2):
         t = 'P2PKH'
     elif address[:2] in (MAINNET_SEGWIT_ADDRESS_PREFIX,
                          TESTNET_SEGWIT_ADDRESS_PREFIX):
@@ -184,7 +194,8 @@ def address_type(address, num = False):
         return SCRIPT_TYPES['NON_STANDARD'] if num else 'UNKNOWN'
     return SCRIPT_TYPES[t] if num else t
 
-def script_to_hash(s, witness = False, hex = False):
+
+def script_to_hash(s, witness=False, hex=False):
     if type(s) == str:
         s = unhexlify(s)
     if witness:
@@ -192,7 +203,8 @@ def script_to_hash(s, witness = False, hex = False):
     else:
         return hash160(s, hex)
 
-def address_to_script(address, hex = False):
+
+def address_to_script(address, hex=False):
     if address[0] in (TESTNET_SCRIPT_ADDRESS_PREFIX,
                       MAINNET_SCRIPT_ADDRESS_PREFIX):
         s = [BYTE_OPCODE["OP_HASH160"],
@@ -200,33 +212,34 @@ def address_to_script(address, hex = False):
              address_to_hash(address),
              BYTE_OPCODE["OP_EQUAL"]]
     elif address[0] in (MAINNET_ADDRESS_PREFIX,
-                      TESTNET_ADDRESS_PREFIX,
-                      TESTNET_ADDRESS_PREFIX_2):
-        s =  [BYTE_OPCODE["OP_DUP"],
-              BYTE_OPCODE["OP_HASH160"],
-              b'\x14',
-              address_to_hash(address),
-              BYTE_OPCODE["OP_EQUALVERIFY"],
-              BYTE_OPCODE["OP_CHECKSIG"]]
+                        TESTNET_ADDRESS_PREFIX,
+                        TESTNET_ADDRESS_PREFIX_2):
+        s = [BYTE_OPCODE["OP_DUP"],
+             BYTE_OPCODE["OP_HASH160"],
+             b'\x14',
+             address_to_hash(address),
+             BYTE_OPCODE["OP_EQUALVERIFY"],
+             BYTE_OPCODE["OP_CHECKSIG"]]
     elif address[:2] in (TESTNET_SEGWIT_ADDRESS_PREFIX,
-                      MAINNET_SEGWIT_ADDRESS_PREFIX):
+                         MAINNET_SEGWIT_ADDRESS_PREFIX):
         h = address_to_hash(address)
-        s =  [BYTE_OPCODE["OP_0"],
-              bytes([len(h)]),
-              h]
+        s = [BYTE_OPCODE["OP_0"],
+             bytes([len(h)]),
+             h]
     else:
         assert False
     s = b''.join(s)
     return hexlify(s).decode() if hex else s
 
-def public_key_to_P2SH_P2WPKH_script(pubkey):
+
+def public_key_to_p2sh_p2wpkh_script(pubkey):
     assert len(pubkey) == 33
     return b'\x00\x14' + hash160(pubkey)
 
 
-def public_key_to_address(pubkey, testnet = False,
-                          p2sh_p2wpkh = False,
-                          witness_version = 0):
+def public_key_to_address(pubkey, testnet=False,
+                          p2sh_p2wpkh=False,
+                          witness_version=0):
     if type(pubkey) == str:
         pubkey = unhexlify(pubkey)
     if p2sh_p2wpkh:
@@ -237,9 +250,10 @@ def public_key_to_address(pubkey, testnet = False,
         if witness_version is not None:
             assert len(pubkey) == 33
         h = hash160(pubkey)
-    return hash_to_address(h, testnet = testnet,
-                           script_hash = p2sh_p2wpkh,
-                           witness_version = witness_version)
+    return hash_to_address(h, testnet=testnet,
+                           script_hash=p2sh_p2wpkh,
+                           witness_version=witness_version)
+
 
 def parse_script(script, segwit=True):
     if type(script) == str:
@@ -324,7 +338,8 @@ def parse_script(script, segwit=True):
         s += 1
     return {"nType": 7, "type": "NON_STANDARD",  "reqSigs": req_sigs, "script": script}
 
-def decode_script(script, asm = False):
+
+def decode_script(script, asm=False):
     if type(script) == str:
         try:
             script = unhexlify(script)
@@ -353,9 +368,7 @@ def decode_script(script, asm = False):
     return ' '.join(result)
 
 
-
-
-def is_address_valid(address, testnet = False):
+def is_address_valid(address, testnet=False):
     if not address or type(address) != str:
         return False
     if address[0] in (MAINNET_ADDRESS_PREFIX,
@@ -373,7 +386,8 @@ def is_address_valid(address, testnet = False):
                                   MAINNET_SCRIPT_ADDRESS_PREFIX):
                 return False
         h = decode_base58(address)
-        if len(h) != 25:  return False
+        if len(h) != 25:
+            return False
         checksum = h[-4:]
         if double_sha256(h[:-4])[:4] != checksum:
             return False
@@ -392,10 +406,10 @@ def is_address_valid(address, testnet = False):
                 if not i.isupper() or i not in base32charset_upcase:
                     return False
             else:
-              if i.isupper() or i not in base32charset:
-                return False
+                if i.isupper() or i not in base32charset:
+                    return False
         payload = payload.lower()
-        prefix  = prefix.lower()
+        prefix = prefix.lower()
         if testnet:
             if prefix != TESTNET_SEGWIT_ADDRESS_PREFIX:
                 return False
@@ -414,30 +428,25 @@ def is_address_valid(address, testnet = False):
         return True
 
 
-
-
 #
 # ECDSA
 #
 
-def verify_signature(sig, pubKey, msg):
+def verify_signature(sig, pub_key, msg):
     if type(sig) != bytes:
         if type(sig) == bytearray:
             sig = bytes(sig)
-
         elif type(sig) == str:
             sig = unhexlify(sig)
-        else :
+        else:
             raise TypeError("signature must be a bytes or hex encoded string")
-    if type(pubKey) != bytes:
-        if type(pubKey) == bytearray:
-            pubKey = bytes(pubKey)
-
-        elif type(pubKey) == str:
-            pubKey = unhexlify(pubKey)
-        else :
+    if type(pub_key) != bytes:
+        if type(pub_key) == bytearray:
+            pub_key = bytes(pub_key)
+        elif type(pub_key) == str:
+            pub_key = unhexlify(pub_key)
+        else:
             raise TypeError("public key must be a bytes or hex encoded string")
-
     if type(msg) != bytes:
         if type(msg) == bytearray:
             msg = bytes(msg)
@@ -445,17 +454,17 @@ def verify_signature(sig, pubKey, msg):
             msg = unhexlify(msg)
         else:
             raise TypeError("message must be a bytes or hex encoded string")
-
     raw_sig = ffi.new('secp256k1_ecdsa_signature *')
     raw_pubkey = ffi.new('secp256k1_pubkey *')
-    if not secp256k1.secp256k1_ecdsa_signature_parse_der(ECDSA_CONTEXT_VERIFY , raw_sig, sig, len(sig)):
+    if not secp256k1.secp256k1_ecdsa_signature_parse_der(ECDSA_CONTEXT_VERIFY, raw_sig, sig, len(sig)):
         raise TypeError("signature must be DER encoded")
-    if not secp256k1.secp256k1_ec_pubkey_parse(ECDSA_CONTEXT_VERIFY, raw_pubkey, pubKey, len(pubKey)):
+    if not secp256k1.secp256k1_ec_pubkey_parse(ECDSA_CONTEXT_VERIFY, raw_pubkey, pub_key, len(pub_key)):
         raise TypeError("public key format error")
     result = secp256k1.secp256k1_ecdsa_verify(ECDSA_CONTEXT_VERIFY, raw_sig, msg, raw_pubkey)
     return True if result else False
 
-def sign_message(msg, private_key, hex = False):
+
+def sign_message(msg, private_key, hex=False):
     """
     :param msg:  message to sign 
     :param private_key:  private key (bytes, hex encoded string)
@@ -470,7 +479,7 @@ def sign_message(msg, private_key, hex = False):
             msg = unhexlify(msg)
         else :
             raise TypeError("message must be a bytes or hex encoded string")
-    if type(private_key)!= bytes:
+    if type(private_key) != bytes:
         if type(private_key) == bytearray:
             private_key = bytes(private_key)
         elif type(private_key) == str:
@@ -478,16 +487,19 @@ def sign_message(msg, private_key, hex = False):
         else:
             raise TypeError("private key must be a bytes or hex encoded string")
     raw_sig = ffi.new('secp256k1_ecdsa_signature *')
-    signed = secp256k1.secp256k1_ecdsa_sign(ECDSA_CONTEXT_SIGN, raw_sig, msg, private_key, ffi.NULL, ffi.NULL)
+    signed = secp256k1.secp256k1_ecdsa_sign(ECDSA_CONTEXT_SIGN, raw_sig, msg,
+                                            private_key, ffi.NULL, ffi.NULL)
     assert signed == 1
     len_sig = 74
     output = ffi.new('unsigned char[%d]' % len_sig)
     outputlen = ffi.new('size_t *', len_sig)
-    res = secp256k1.secp256k1_ecdsa_signature_serialize_der(ECDSA_CONTEXT_SIGN, output, outputlen, raw_sig)
+    res = secp256k1.secp256k1_ecdsa_signature_serialize_der(ECDSA_CONTEXT_SIGN,
+                                                            output, outputlen, raw_sig)
     assert res == 1
-    signature =  bytes(ffi.buffer(output, outputlen[0]))
+    signature = bytes(ffi.buffer(output, outputlen[0]))
     return hexlify(signature).decode() if hex else signature
 
+
 def is_valid_signature_encoding(sig):
     # Format: 0x30 [total-length] 0x02 [R-length] [R] 0x02 [S-length] [S] [sighash]
     # * total-length: 1-byte length descriptor of everything that follows,
@@ -500,7 +512,6 @@ def is_valid_signature_encoding(sig):
     # * S: arbitrary-length big-endian encoded S value. The same rules apply.
     # * sighash: 1-byte value indicating what data is hashed (not part of the DER
     #   signature)
-
     length = len(sig)
     # Minimum and maximum size constraints.
     if (length < 9) or (length > 73):
@@ -512,41 +523,41 @@ def is_valid_signature_encoding(sig):
     if sig[1] != (length - 3):
         return False
     # Extract the length of the R element.
-    lenR = sig[3]
+    len_r = sig[3]
     # Make sure the length of the S element is still inside the signature.
-    if (5 + lenR) >= length:
+    if (5 + len_r) >= length:
         return False
     # Extract the length of the S element.
-    lenS = sig[5 + lenR]
+    len_s = sig[5 + len_r]
     # Verify that the length of the signature matches the sum of the length
     # of the elements.
-    if (lenR + lenS + 7) != length:
+    if (len_r + len_s + 7) != length:
         return False
     # Check whether the R element is an integer.
     if sig[2] != 0x02:
         return False
     # Zero-length integers are not allowed for R.
-    if lenR == 0:
+    if len_r == 0:
         return False
     # Negative numbers are not allowed for R.
     if sig[4] & 0x80:
         return False
     # Null bytes at the start of R are not allowed, unless R would
     # otherwise be interpreted as a negative number.
-    if (lenR > 1) and (sig[4] == 0x00) and (not sig[5] & 0x80):
+    if (len_r > 1) and (sig[4] == 0x00) and (not sig[5] & 0x80):
         return False
     # Check whether the S element is an integer.
-    if sig[lenR + 4] != 0x02:
+    if sig[len_r + 4] != 0x02:
         return False
     # Zero-length integers are not allowed for S.
-    if lenS == 0:
+    if len_s == 0:
         return False
     # Negative numbers are not allowed for S.
-    if sig[lenR + 6] & 0x80:
+    if sig[len_r + 6] & 0x80:
         return False
     # Null bytes at the start of S are not allowed, unless S would otherwise be
     # interpreted as a negative number.
-    if (lenS > 1) and (sig[lenR + 6] == 0x00) and (not sig[lenR + 7] & 0x80):
+    if (len_s > 1) and (sig[len_r + 6] == 0x00) and (not sig[len_r + 7] & 0x80):
         return False
     return True
 
@@ -556,15 +567,20 @@ def is_valid_signature_encoding(sig):
 #
 
 def rh2s(tthash):
+    # raw hash to string
     return hexlify(tthash[::-1]).decode()
 
+
 def s2rh(hash_string):
+    # string to raw hash
     return unhexlify(hash_string)[::-1]
 
+
 def s2rh_step4(hash_string):
     h = unhexlify(hash_string)
     return reverse_hash(h)
 
+
 def reverse_hash(h):
     return struct.pack('>IIIIIIII', *struct.unpack('>IIIIIIII', h)[::-1])[::-1]
 
@@ -572,6 +588,7 @@ def reverse_hash(h):
 #
 #
 
+
 def merkleroot(tx_hash_list):
     tx_hash_list = list(tx_hash_list)
     if len(tx_hash_list) == 1:
@@ -590,6 +607,7 @@ def merkleroot(tx_hash_list):
         else:
             return new_hash_list[0]
 
+
 def merkle_branches(tx_hash_list):
     tx_hash_list = list(tx_hash_list)
     branches = []
@@ -613,6 +631,7 @@ def merkle_branches(tx_hash_list):
                 branches.append(new_hash_list.pop(0))
             return branches
 
+
 def merkleroot_from_branches(merkle_branches, coinbase_hash_bin):
     merkle_root = coinbase_hash_bin
     for h in merkle_branches:
@@ -621,6 +640,7 @@ def merkleroot_from_branches(merkle_branches, coinbase_hash_bin):
         merkle_root = double_sha256(merkle_root + h)
     return merkle_root
 
+
 def bits_to_target(bits):
     if type(bits) == str:
         bits = unhexlify(bits)
@@ -631,12 +651,15 @@ def bits_to_target(bits):
         target = (bits & 0xffffff) * (1 << (8 * (shift - 3)))
         return target
 
+
 def target_to_difficulty(target):
     return 0x00000000FFFF0000000000000000000000000000000000000000000000000000 / target
 
+
 def bits_to_difficulty(bits):
     return target_to_difficulty(bits_to_target(bits))
 
+
 def difficulty_to_target(difficulty):
     return int(0x00000000FFFF0000000000000000000000000000000000000000000000000000 / difficulty)
 
@@ -647,12 +670,14 @@ def difficulty_to_target(difficulty):
 
 def bytes_needed(n):
     if n == 0:
-     return 1
+        return 1
     return math.ceil(n.bit_length()/8)
 
+
 def int_to_bytes(i, byteorder='big'):
     return i.to_bytes(bytes_needed(i), byteorder=byteorder, signed=False)
 
+
 def bytes_to_int(i, byteorder='big'):
     return int.from_bytes(i, byteorder=byteorder, signed=False)
 
@@ -668,6 +693,7 @@ def int_to_var_int(i):
         return b'\xfe' + struct.pack('<L', i)
     return b'\xff' +  struct.pack('<Q', i)
 
+
 def var_int_to_int(data):
     if data[0] == 0xfd:
         return struct.unpack('<H', data[1:3])[0]
@@ -677,6 +703,7 @@ def var_int_to_int(data):
         return struct.unpack('<Q', data[1:9])[0]
     return data[0]
 
+
 def var_int_len(n):
     if n <= 0xfc:
         return 1
@@ -686,26 +713,30 @@ def var_int_len(n):
         return 5
     return 9
 
+
 def get_var_int_len(byte):
     if byte[0] == 253:
-       return 3
+        return 3
     elif byte[0] == 254:
-       return 5
+        return 5
     elif byte[0] == 255:
-       return 9
+        return 9
     return 1
 
+
 def read_var_int(stream):
     l = stream.read(1)
     bytes_length = get_var_int_len(l)
     return l + stream.read(bytes_length - 1)
 
+
 def read_var_list(stream, data_type):
     count = var_int_to_int(read_var_int(stream))
     return [data_type.deserialize(stream) for i in range(count)]
 
 # compressed integer
 
+
 def int_to_c_int(n, base_bytes=1):
     if n == 0:
         return b'\x00'
@@ -722,11 +753,12 @@ def int_to_c_int(n, base_bytes=1):
     if l < base_bytes * 8:
         l = base_bytes * 8
     prefix = prefix << l
-    if prefix.bit_length()  % 8:
-        prefix = prefix << 8 - prefix.bit_length()  % 8
+    if prefix.bit_length() % 8:
+        prefix = prefix << 8 - prefix.bit_length() % 8
     n ^= prefix
     return n.to_bytes(math.ceil(n.bit_length()/8), byteorder="big")
 
+
 def c_int_to_int(b, base_bytes=1):
     byte_length = 0
     f = 0
@@ -745,6 +777,7 @@ def c_int_to_int(b, base_bytes=1):
         return n & ((1 << (byte_length+base_bytes) * 8 - byte_length) - 1)
     return n
 
+
 def c_int_len(n, base_bytes=1):
     if n == 0:
         return 1
@@ -753,11 +786,7 @@ def c_int_len(n, base_bytes=1):
     if l <= min_bits + 1:
         return 1
     payload_bytes = math.ceil((l)/8) - base_bytes
-    return  int(math.ceil((l+payload_bytes)/8))
-
-
-
-
+    return int(math.ceil((l+payload_bytes)/8))
 
 
 # generic big endian MPI format
@@ -788,12 +817,10 @@ def bn2mpi(v):
     have_ext = False
     if v.bit_length() > 0:
         have_ext = (v.bit_length() & 0x07) == 0
-
     neg = False
     if v < 0:
         neg = True
         v = -v
-
     s = struct.pack(b">I", bn_bytes(v, have_ext))
     ext = bytearray()
     if have_ext:
@@ -816,7 +843,6 @@ def mpi2bn(s):
         return None
     if v_len == 0:
         return 0
-
     v_str = bytearray(s[4:])
     neg = False
     i = v_str[0]
@@ -824,7 +850,6 @@ def mpi2bn(s):
         neg = True
         i &= ~0x80
         v_str[0] = i
-
     v = bin2bn(v_str)
 
     if neg:
@@ -861,6 +886,7 @@ def i2b(i): return bn2vch(i)
 
 def b2i(b): return vch2bn(b)
 
+
 def get_stream(stream):
     if type(stream) != io.BytesIO:
         if type(stream) == str:
diff --git a/tests/test/address_functions.py b/tests/test/address_functions.py
index f7730d5..8b4ab53 100644
--- a/tests/test/address_functions.py
+++ b/tests/test/address_functions.py
@@ -20,36 +20,36 @@ class AddressFunctionsTests(unittest.TestCase):
         pum = "5KPPLXhtga99qqMceRo4Z6LXV3Kx6a9hRx3ez2U7EwP5KZfy2Wf"
         put = "93A1vGXSGoDHotruGmgyRgtV8hgfFjgtmtuc4epcag886W9d44L"
         pct = "cUWo47XLYiyFByuFicFS3y4FAza3r3R5XA7Bm7wA3dgSKDYox7h6"
-        self.assertEqual(tools.private_key_to_WIF(p, compressed=1, testnet=0), pcm)
-        self.assertEqual(tools.private_key_to_WIF(p, compressed=0, testnet=0), pum)
-        self.assertEqual(tools.private_key_to_WIF(p, compressed=1, testnet=1), pct)
-        self.assertEqual(tools.private_key_to_WIF(p, compressed=0, testnet=1), put)
+        self.assertEqual(tools.private_key_to_wif(p, compressed=1, testnet=0), pcm)
+        self.assertEqual(tools.private_key_to_wif(p, compressed=0, testnet=0), pum)
+        self.assertEqual(tools.private_key_to_wif(p, compressed=1, testnet=1), pct)
+        self.assertEqual(tools.private_key_to_wif(p, compressed=0, testnet=1), put)
 
     def test_is_WIF_valid(self):
-        self.assertEqual(tools.is_WIF_valid("L49obCXV7fGz2YRzLCSJgeZBYmGeBbKPT7xiehUeYX2S4URkPFZX"),1)
-        self.assertEqual(tools.is_WIF_valid("5KPPLXhtga99qqMceRo4Z6LXV3Kx6a9hRx3ez2U7EwP5KZfy2Wf"),1)
-        self.assertEqual(tools.is_WIF_valid("5KPPLXhtga99qqMcWRo4Z6LXV3Kx6a9hRx3ez2U7EwP5KZfy2Wf"),0)
-        self.assertEqual(tools.is_WIF_valid("93A1vGXSGoDHotruGmgyRgtV8hgfFjgtmtuc4epcag886W9d44L"),1)
-        self.assertEqual(tools.is_WIF_valid("cUWo47XLYiyFByuFicFS3y4FAza3r3R5XA7Bm7wA3dgSKDYox7h6"),1)
-        self.assertEqual(tools.is_WIF_valid("cUWo47XLYiyByuFicFS3y4FAza3r3R5XA7Bm7wA3dgSKDYox7h6"),0)
+        self.assertEqual(tools.is_wif_valid("L49obCXV7fGz2YRzLCSJgeZBYmGeBbKPT7xiehUeYX2S4URkPFZX"), 1)
+        self.assertEqual(tools.is_wif_valid("5KPPLXhtga99qqMceRo4Z6LXV3Kx6a9hRx3ez2U7EwP5KZfy2Wf"), 1)
+        self.assertEqual(tools.is_wif_valid("5KPPLXhtga99qqMcWRo4Z6LXV3Kx6a9hRx3ez2U7EwP5KZfy2Wf"), 0)
+        self.assertEqual(tools.is_wif_valid("93A1vGXSGoDHotruGmgyRgtV8hgfFjgtmtuc4epcag886W9d44L"), 1)
+        self.assertEqual(tools.is_wif_valid("cUWo47XLYiyFByuFicFS3y4FAza3r3R5XA7Bm7wA3dgSKDYox7h6"), 1)
+        self.assertEqual(tools.is_wif_valid("cUWo47XLYiyByuFicFS3y4FAza3r3R5XA7Bm7wA3dgSKDYox7h6"), 0)
 
     def test_WIF_to_private_key(self):
         p = "ceda1ae4286015d45ec5147fe3f63e9377ccd6d4e98bcf0847df9937da1944a4"
-        self.assertEqual(tools.WIF_to_private_key("L49obCXV7fGz2YRzLCSJgeZBYmGeBbKPT7xiehUeYX2S4URkPFZX",
+        self.assertEqual(tools.wif_to_private_key("L49obCXV7fGz2YRzLCSJgeZBYmGeBbKPT7xiehUeYX2S4URkPFZX",
                                                   hex=1),p)
-        self.assertEqual(tools.WIF_to_private_key("L49obCXV7fGz2YRzLCSJgeZBYmGeBbKPT7xiehUeYX2S4URkPFZX",
+        self.assertEqual(tools.wif_to_private_key("L49obCXV7fGz2YRzLCSJgeZBYmGeBbKPT7xiehUeYX2S4URkPFZX",
                                                   hex=0),unhexlify(p))
-        self.assertEqual(tools.WIF_to_private_key("5KPPLXhtga99qqMceRo4Z6LXV3Kx6a9hRx3ez2U7EwP5KZfy2Wf",
+        self.assertEqual(tools.wif_to_private_key("5KPPLXhtga99qqMceRo4Z6LXV3Kx6a9hRx3ez2U7EwP5KZfy2Wf",
                                                   hex=1),p)
-        self.assertEqual(tools.WIF_to_private_key("93A1vGXSGoDHotruGmgyRgtV8hgfFjgtmtuc4epcag886W9d44L",
+        self.assertEqual(tools.wif_to_private_key("93A1vGXSGoDHotruGmgyRgtV8hgfFjgtmtuc4epcag886W9d44L",
                                                   hex=1),p)
-        self.assertEqual(tools.WIF_to_private_key("cUWo47XLYiyFByuFicFS3y4FAza3r3R5XA7Bm7wA3dgSKDYox7h6",
+        self.assertEqual(tools.wif_to_private_key("cUWo47XLYiyFByuFicFS3y4FAza3r3R5XA7Bm7wA3dgSKDYox7h6",
                                                   hex=1),p)
 
     def test_create_private_key(self):
         p = tools.create_private_key()
-        pw = tools.private_key_to_WIF(p)
-        self.assertEqual(tools.is_WIF_valid(pw), True)
+        pw = tools.private_key_to_wif(p)
+        self.assertEqual(tools.is_wif_valid(pw), True)
 
 
 
diff --git a/tests/test/transaction_deserialize.py b/tests/test/transaction_deserialize.py
index 5454bd3..5833257 100644
--- a/tests/test/transaction_deserialize.py
+++ b/tests/test/transaction_deserialize.py
@@ -1,14 +1,16 @@
 import unittest
-import os, sys
+import os
+import sys
 import time
 parentPath = os.path.abspath("..")
 if parentPath not in sys.path:
     sys.path.insert(0, parentPath)
+
 from pybtc.tools import *
 from pybtc.hash import *
 from pybtc.transaction import *
 from binascii import unhexlify
-from pybtc import address_to_hash  as address2hash160
+from pybtc import address_to_hash as address2hash160
 
 
 def decode_block_tx(block):