[qa] Use integer division, byte strings properly

qa/pull-tester/rpc-tests.py

@@ -123,6 +123,7 @@
     'abandonconflict.py',
     'p2p-versionbits-warning.py',
     'p2p-segwit.py',
+    'segwit.py',
     'importprunedfunds.py',
 ]
 if ENABLE_ZMQ:

qa/rpc-tests/segwit.py

@@ -9,44 +9,37 @@
 
 from test_framework.test_framework import BitcoinTestFramework
 from test_framework.util import *
+from test_framework.mininode import sha256, ripemd160
 import os
 import shutil
-import hashlib
-from binascii import hexlify
 
 NODE_0 = 0
 NODE_1 = 1
 NODE_2 = 2
 WIT_V0 = 0
 WIT_V1 = 1
 
-def sha256(s):
-    return hashlib.new('sha256', s).digest()
-
-def ripemd160(s):
-    return hashlib.new('ripemd160', s).digest()
-
 def witness_script(version, pubkey):
     if (version == 0):
-        pubkeyhash = hexlify(ripemd160(sha256(pubkey.decode("hex"))))
+        pubkeyhash = bytes_to_hex_str(ripemd160(sha256(hex_str_to_bytes(pubkey))))
         pkscript = "0014" + pubkeyhash
     elif (version == 1):
         # 1-of-1 multisig
-        scripthash = hexlify(sha256(("5121" + pubkey + "51ae").decode("hex")))
+        scripthash = bytes_to_hex_str(sha256(hex_str_to_bytes("5121" + pubkey + "51ae")))
         pkscript = "0020" + scripthash
     else:
         assert("Wrong version" == "0 or 1")
     return pkscript
 
 def addlength(script):
-    scriptlen = format(len(script)/2, 'x')
+    scriptlen = format(len(script)//2, 'x')
     assert(len(scriptlen) == 2)
     return scriptlen + script
 
 def create_witnessprogram(version, node, utxo, pubkey, encode_p2sh, amount):
     pkscript = witness_script(version, pubkey);
     if (encode_p2sh):
-        p2sh_hash = hexlify(ripemd160(sha256(pkscript.decode("hex"))))
+        p2sh_hash = bytes_to_hex_str(ripemd160(sha256(hex_str_to_bytes(pkscript))))
         pkscript = "a914"+p2sh_hash+"87"
     inputs = []
     outputs = {}

qa/rpc-tests/test_framework/blocktools.py

@@ -23,7 +23,7 @@ def create_block(hashprev, coinbase, nTime=None):
     return block
 
 # From BIP141
-WITNESS_COMMITMENT_HEADER = "\xaa\x21\xa9\xed"
+WITNESS_COMMITMENT_HEADER = b"\xaa\x21\xa9\xed"
 
 # According to BIP141, nVersion=5 blocks must commit to the
 # hash of all in-block transactions including witness.

qa/rpc-tests/test_framework/mininode.py

@@ -63,6 +63,8 @@
 def sha256(s):
     return hashlib.new('sha256', s).digest()
 
+def ripemd160(s):
+    return hashlib.new('ripemd160', s).digest()
 
 def hash256(s):
     return sha256(sha256(s))
@@ -440,7 +442,7 @@ def deserialize(self, f):
             self.vtxinwit[i].deserialize(f)
 
     def serialize(self):
-        r = ""
+        r = b""
         # This is different than the usual vector serialization --
         # we omit the length of the vector, which is required to be
         # the same length as the transaction's vin vector.

qa/rpc-tests/test_framework/script.py

@@ -911,27 +911,27 @@ def SegwitVersion1SignatureHash(script, txTo, inIdx, hashtype, amount):
     hashOutputs = 0L
 
     if not (hashtype & SIGHASH_ANYONECANPAY):
-        serialize_prevouts = str()
+        serialize_prevouts = bytes()
         for i in txTo.vin:
             serialize_prevouts += i.prevout.serialize()
         hashPrevouts = uint256_from_str(hash256(serialize_prevouts))
 
     if (not (hashtype & SIGHASH_ANYONECANPAY) and (hashtype & 0x1f) != SIGHASH_SINGLE and (hashtype & 0x1f) != SIGHASH_NONE):
-        serialize_sequence = str()
+        serialize_sequence = bytes()
         for i in txTo.vin:
             serialize_sequence += struct.pack("<I", i.nSequence)
         hashSequence = uint256_from_str(hash256(serialize_sequence))
 
     if ((hashtype & 0x1f) != SIGHASH_SINGLE and (hashtype & 0x1f) != SIGHASH_NONE):
-        serialize_outputs = str()
+        serialize_outputs = bytes()
         for o in txTo.vout:
             serialize_outputs += o.serialize()
         hashOutputs = uint256_from_str(hash256(serialize_outputs))
     elif ((hashtype & 0x1f) == SIGHASH_SINGLE and inIdx < len(txTo.vout)):
         serialize_outputs = txTo.vout[inIdx].serialize()
         hashOutputs = uint256_from_str(hash256(serialize_outputs))
 
-    ss = str()
+    ss = bytes()
     ss += struct.pack("<i", txTo.nVersion)
     ss += ser_uint256(hashPrevouts)
     ss += ser_uint256(hashSequence)