diff --git a/qa/pull-tester/rpc-tests.py b/qa/pull-tester/rpc-tests.py
index 0a0d639b69720..9200811b14558 100755
--- a/qa/pull-tester/rpc-tests.py
+++ b/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:
diff --git a/qa/rpc-tests/p2p-segwit.py b/qa/rpc-tests/p2p-segwit.py
index b241bac26e4ce..5dd0d226be970 100755
--- a/qa/rpc-tests/p2p-segwit.py
+++ b/qa/rpc-tests/p2p-segwit.py
@@ -1,8 +1,7 @@
 #!/usr/bin/env python2
-#
-# Distributed under the MIT/X11 software license, see the accompanying
+# Copyright (c) 2016 The Bitcoin Core developers
+# Distributed under the MIT software license, see the accompanying
 # file COPYING or http://www.opensource.org/licenses/mit-license.php.
-#
 
 from test_framework.mininode import *
 from test_framework.test_framework import BitcoinTestFramework
@@ -212,7 +211,7 @@ def test_non_witness_transaction(self):
 
         # Create a transaction that spends the coinbase
         tx = CTransaction()
-        tx.vin.append(CTxIn(COutPoint(txid, 0), ""))
+        tx.vin.append(CTxIn(COutPoint(txid, 0), b""))
         tx.vout.append(CTxOut(49*100000000, CScript([OP_TRUE])))
         tx.calc_sha256()
 
@@ -237,7 +236,7 @@ def test_unnecessary_witness_before_segwit_activation(self):
         assert(get_bip9_status(self.nodes[0], 'witness')['status'] != 'active')
 
         tx = CTransaction()
-        tx.vin.append(CTxIn(COutPoint(self.utxo[0].sha256, self.utxo[0].n), ""))
+        tx.vin.append(CTxIn(COutPoint(self.utxo[0].sha256, self.utxo[0].n), b""))
         tx.vout.append(CTxOut(self.utxo[0].nValue-1000, CScript([OP_TRUE])))
         tx.wit.vtxinwit.append(CTxinWitness())
         tx.wit.vtxinwit[0].scriptWitness.stack = [CScript([CScriptNum(1)])]
@@ -331,7 +330,7 @@ def test_witness_commitments(self):
         # Now test commitments with actual transactions
         assert (len(self.utxo) > 0)
         tx = CTransaction()
-        tx.vin.append(CTxIn(COutPoint(self.utxo[0].sha256, self.utxo[0].n), ""))
+        tx.vin.append(CTxIn(COutPoint(self.utxo[0].sha256, self.utxo[0].n), b""))
 
         # Let's construct a witness program
         witness_program = CScript([OP_TRUE])
@@ -342,7 +341,7 @@ def test_witness_commitments(self):
 
         # tx2 will spend tx1, and send back to a regular anyone-can-spend address
         tx2 = CTransaction()
-        tx2.vin.append(CTxIn(COutPoint(tx.sha256, 0), ""))
+        tx2.vin.append(CTxIn(COutPoint(tx.sha256, 0), b""))
         tx2.vout.append(CTxOut(tx.vout[0].nValue-1000, witness_program))
         tx2.wit.vtxinwit.append(CTxinWitness())
         tx2.wit.vtxinwit[0].scriptWitness.stack = [witness_program]
@@ -379,7 +378,7 @@ def test_witness_commitments(self):
         # omit the commitment.
         block_4 = self.build_next_block()
         tx3 = CTransaction()
-        tx3.vin.append(CTxIn(COutPoint(tx2.sha256, 0), ""))
+        tx3.vin.append(CTxIn(COutPoint(tx2.sha256, 0), b""))
         tx3.vout.append(CTxOut(tx.vout[0].nValue-1000, witness_program))
         tx3.rehash()
         block_4.vtx.append(tx3)
@@ -402,7 +401,7 @@ def test_block_malleability(self):
         add_witness_commitment(block)
         block.solve()
 
-        block.vtx[0].wit.vtxinwit[0].scriptWitness.stack.append('a'*5000000)
+        block.vtx[0].wit.vtxinwit[0].scriptWitness.stack.append(b'a'*5000000)
         assert(get_virtual_size(block) > MAX_BLOCK_SIZE)
 
         # We can't send over the p2p network, because this is too big to relay
@@ -458,7 +457,7 @@ def test_witness_block_size(self):
         value = self.utxo[0].nValue
 
         parent_tx = CTransaction()
-        parent_tx.vin.append(CTxIn(prevout, ""))
+        parent_tx.vin.append(CTxIn(prevout, b""))
         child_value = int(value/NUM_OUTPUTS)
         for i in xrange(NUM_OUTPUTS):
             parent_tx.vout.append(CTxOut(child_value, scriptPubKey))
@@ -468,11 +467,11 @@ def test_witness_block_size(self):
 
         child_tx = CTransaction()
         for i in xrange(NUM_OUTPUTS):
-            child_tx.vin.append(CTxIn(COutPoint(parent_tx.sha256, i), ""))
+            child_tx.vin.append(CTxIn(COutPoint(parent_tx.sha256, i), b""))
         child_tx.vout = [CTxOut(value - 100000, CScript([OP_TRUE]))]
         for i in xrange(NUM_OUTPUTS):
             child_tx.wit.vtxinwit.append(CTxinWitness())
-            child_tx.wit.vtxinwit[-1].scriptWitness.stack = ['a'*195]*(2*NUM_DROPS) + [witness_program]
+            child_tx.wit.vtxinwit[-1].scriptWitness.stack = [b'a'*195]*(2*NUM_DROPS) + [witness_program]
         child_tx.rehash()
         self.update_witness_block_with_transactions(block, [parent_tx, child_tx])
 
@@ -482,7 +481,7 @@ def test_witness_block_size(self):
         while additional_bytes > 0:
             # Add some more bytes to each input until we hit MAX_BLOCK_SIZE+1
             extra_bytes = min(additional_bytes+1, 55)
-            block.vtx[-1].wit.vtxinwit[int(i/(2*NUM_DROPS))].scriptWitness.stack[i%(2*NUM_DROPS)] = 'a'*(195+extra_bytes)
+            block.vtx[-1].wit.vtxinwit[int(i/(2*NUM_DROPS))].scriptWitness.stack[i%(2*NUM_DROPS)] = b'a'*(195+extra_bytes)
             additional_bytes -= extra_bytes
             i += 1
 
@@ -499,7 +498,7 @@ def test_witness_block_size(self):
 
         # Now resize the second transaction to make the block fit.
         cur_length = len(block.vtx[-1].wit.vtxinwit[0].scriptWitness.stack[0])
-        block.vtx[-1].wit.vtxinwit[0].scriptWitness.stack[0] = 'a'*(cur_length-1)
+        block.vtx[-1].wit.vtxinwit[0].scriptWitness.stack[0] = b'a'*(cur_length-1)
         block.vtx[0].vout.pop()
         add_witness_commitment(block)
         block.solve()
@@ -563,7 +562,7 @@ def test_extra_witness_data(self):
 
         # First try extra witness data on a tx that doesn't require a witness
         tx = CTransaction()
-        tx.vin.append(CTxIn(COutPoint(self.utxo[0].sha256, self.utxo[0].n), ""))
+        tx.vin.append(CTxIn(COutPoint(self.utxo[0].sha256, self.utxo[0].n), b""))
         tx.vout.append(CTxOut(self.utxo[0].nValue-2000, scriptPubKey))
         tx.vout.append(CTxOut(1000, CScript([OP_TRUE]))) # non-witness output
         tx.wit.vtxinwit.append(CTxinWitness())
@@ -586,8 +585,8 @@ def test_extra_witness_data(self):
         # Now try extra witness/signature data on an input that DOES require a
         # witness
         tx2 = CTransaction()
-        tx2.vin.append(CTxIn(COutPoint(tx.sha256, 0), "")) # witness output
-        tx2.vin.append(CTxIn(COutPoint(tx.sha256, 1), "")) # non-witness
+        tx2.vin.append(CTxIn(COutPoint(tx.sha256, 0), b"")) # witness output
+        tx2.vin.append(CTxIn(COutPoint(tx.sha256, 1), b"")) # non-witness
         tx2.vout.append(CTxOut(tx.vout[0].nValue, CScript([OP_TRUE])))
         tx2.wit.vtxinwit.extend([CTxinWitness(), CTxinWitness()])
         tx2.wit.vtxinwit[0].scriptWitness.stack = [ CScript([CScriptNum(1)]), CScript([CScriptNum(1)]), witness_program ]
@@ -613,7 +612,7 @@ def test_extra_witness_data(self):
 
         # Now get rid of the extra scriptsig on the witness input, and verify
         # success (even with extra scriptsig data in the non-witness input)
-        tx2.vin[0].scriptSig = ""
+        tx2.vin[0].scriptSig = b""
         tx2.rehash()
         add_witness_commitment(block)
         block.solve()
@@ -638,23 +637,23 @@ def test_max_witness_push_length(self):
         scriptPubKey = CScript([OP_0, witness_hash])
 
         tx = CTransaction()
-        tx.vin.append(CTxIn(COutPoint(self.utxo[0].sha256, self.utxo[0].n), ""))
+        tx.vin.append(CTxIn(COutPoint(self.utxo[0].sha256, self.utxo[0].n), b""))
         tx.vout.append(CTxOut(self.utxo[0].nValue-1000, scriptPubKey))
         tx.rehash()
 
         tx2 = CTransaction()
-        tx2.vin.append(CTxIn(COutPoint(tx.sha256, 0), ""))
+        tx2.vin.append(CTxIn(COutPoint(tx.sha256, 0), b""))
         tx2.vout.append(CTxOut(tx.vout[0].nValue-1000, CScript([OP_TRUE])))
         tx2.wit.vtxinwit.append(CTxinWitness())
         # First try a 521-byte stack element
-        tx2.wit.vtxinwit[0].scriptWitness.stack = [ 'a'*(MAX_SCRIPT_ELEMENT_SIZE+1), witness_program ]
+        tx2.wit.vtxinwit[0].scriptWitness.stack = [ b'a'*(MAX_SCRIPT_ELEMENT_SIZE+1), witness_program ]
         tx2.rehash()
 
         self.update_witness_block_with_transactions(block, [tx, tx2])
         self.test_node.test_witness_block(block, accepted=False)
 
         # Now reduce the length of the stack element
-        tx2.wit.vtxinwit[0].scriptWitness.stack[0] = 'a'*(MAX_SCRIPT_ELEMENT_SIZE)
+        tx2.wit.vtxinwit[0].scriptWitness.stack[0] = b'a'*(MAX_SCRIPT_ELEMENT_SIZE)
 
         add_witness_commitment(block)
         block.solve()
@@ -672,7 +671,7 @@ def test_max_witness_program_length(self):
         MAX_PROGRAM_LENGTH = 10000
 
         # This program is 19 max pushes (9937 bytes), then 64 more opcode-bytes.
-        long_witness_program = CScript(['a'*520]*19 + [OP_DROP]*63 + [OP_TRUE])
+        long_witness_program = CScript([b'a'*520]*19 + [OP_DROP]*63 + [OP_TRUE])
         assert(len(long_witness_program) == MAX_PROGRAM_LENGTH+1)
         long_witness_hash = sha256(long_witness_program)
         long_scriptPubKey = CScript([OP_0, long_witness_hash])
@@ -680,15 +679,15 @@ def test_max_witness_program_length(self):
         block = self.build_next_block()
 
         tx = CTransaction()
-        tx.vin.append(CTxIn(COutPoint(self.utxo[0].sha256, self.utxo[0].n), ""))
+        tx.vin.append(CTxIn(COutPoint(self.utxo[0].sha256, self.utxo[0].n), b""))
         tx.vout.append(CTxOut(self.utxo[0].nValue-1000, long_scriptPubKey))
         tx.rehash()
 
         tx2 = CTransaction()
-        tx2.vin.append(CTxIn(COutPoint(tx.sha256, 0), ""))
+        tx2.vin.append(CTxIn(COutPoint(tx.sha256, 0), b""))
         tx2.vout.append(CTxOut(tx.vout[0].nValue-1000, CScript([OP_TRUE])))
         tx2.wit.vtxinwit.append(CTxinWitness())
-        tx2.wit.vtxinwit[0].scriptWitness.stack = ['a']*44 + [long_witness_program]
+        tx2.wit.vtxinwit[0].scriptWitness.stack = [b'a']*44 + [long_witness_program]
         tx2.rehash()
 
         self.update_witness_block_with_transactions(block, [tx, tx2])
@@ -696,7 +695,7 @@ def test_max_witness_program_length(self):
         self.test_node.test_witness_block(block, accepted=False)
 
         # Try again with one less byte in the witness program
-        witness_program = CScript(['a'*520]*19 + [OP_DROP]*62 + [OP_TRUE])
+        witness_program = CScript([b'a'*520]*19 + [OP_DROP]*62 + [OP_TRUE])
         assert(len(witness_program) == MAX_PROGRAM_LENGTH)
         witness_hash = sha256(witness_program)
         scriptPubKey = CScript([OP_0, witness_hash])
@@ -704,7 +703,7 @@ def test_max_witness_program_length(self):
         tx.vout[0] = CTxOut(tx.vout[0].nValue, scriptPubKey)
         tx.rehash()
         tx2.vin[0].prevout.hash = tx.sha256
-        tx2.wit.vtxinwit[0].scriptWitness.stack = ['a']*43 + [witness_program]
+        tx2.wit.vtxinwit[0].scriptWitness.stack = [b'a']*43 + [witness_program]
         tx2.rehash()
         block.vtx = [block.vtx[0]]
         self.update_witness_block_with_transactions(block, [tx, tx2])
@@ -725,7 +724,7 @@ def test_witness_input_length(self):
         
         # Create a transaction that splits our utxo into many outputs
         tx = CTransaction()
-        tx.vin.append(CTxIn(COutPoint(self.utxo[0].sha256, self.utxo[0].n), ""))
+        tx.vin.append(CTxIn(COutPoint(self.utxo[0].sha256, self.utxo[0].n), b""))
         nValue = self.utxo[0].nValue
         for i in xrange(10):
             tx.vout.append(CTxOut(int(nValue/10), scriptPubKey))
@@ -744,7 +743,7 @@ def serialize_with_witness(self):
                 flags = 0
                 if not self.wit.is_null():
                     flags |= 1
-                r = ""
+                r = b""
                 r += struct.pack("<i", self.nVersion)
                 if flags:
                     dummy = []
@@ -759,13 +758,13 @@ def serialize_with_witness(self):
 
         tx2 = BrokenCTransaction()
         for i in xrange(10):
-            tx2.vin.append(CTxIn(COutPoint(tx.sha256, i), ""))
+            tx2.vin.append(CTxIn(COutPoint(tx.sha256, i), b""))
         tx2.vout.append(CTxOut(nValue-3000, CScript([OP_TRUE])))
 
         # First try using a too long vtxinwit
         for i in xrange(11):
             tx2.wit.vtxinwit.append(CTxinWitness())
-            tx2.wit.vtxinwit[i].scriptWitness.stack = ['a', witness_program]
+            tx2.wit.vtxinwit[i].scriptWitness.stack = [b'a', witness_program]
 
         block = self.build_next_block()
         self.update_witness_block_with_transactions(block, [tx2])
@@ -781,7 +780,7 @@ def serialize_with_witness(self):
 
         # Now make one of the intermediate witnesses be incorrect
         tx2.wit.vtxinwit.append(CTxinWitness())
-        tx2.wit.vtxinwit[-1].scriptWitness.stack = ['a', witness_program]
+        tx2.wit.vtxinwit[-1].scriptWitness.stack = [b'a', witness_program]
         tx2.wit.vtxinwit[5].scriptWitness.stack = [ witness_program ]
 
         block.vtx = [block.vtx[0]]
@@ -789,7 +788,7 @@ def serialize_with_witness(self):
         self.test_node.test_witness_block(block, accepted=False)
 
         # Fix the broken witness and the block should be accepted.
-        tx2.wit.vtxinwit[5].scriptWitness.stack = ['a', witness_program]
+        tx2.wit.vtxinwit[5].scriptWitness.stack = [b'a', witness_program]
         block.vtx = [block.vtx[0]]
         self.update_witness_block_with_transactions(block, [tx2])
         self.test_node.test_witness_block(block, accepted=True)
@@ -805,10 +804,10 @@ def test_witness_tx_relay_before_segwit_activation(self):
         # not be added to recently rejected list.
         assert(len(self.utxo))
         tx = CTransaction()
-        tx.vin.append(CTxIn(COutPoint(self.utxo[0].sha256, self.utxo[0].n), ""))
+        tx.vin.append(CTxIn(COutPoint(self.utxo[0].sha256, self.utxo[0].n), b""))
         tx.vout.append(CTxOut(self.utxo[0].nValue-1000, CScript([OP_TRUE])))
         tx.wit.vtxinwit.append(CTxinWitness())
-        tx.wit.vtxinwit[0].scriptWitness.stack = [ 'a' ]
+        tx.wit.vtxinwit[0].scriptWitness.stack = [ b'a' ]
         tx.rehash()
 
         tx_hash = tx.sha256
@@ -865,10 +864,10 @@ def test_tx_relay_after_segwit_activation(self):
         # when spending a non-witness output.
         assert(len(self.utxo))
         tx = CTransaction()
-        tx.vin.append(CTxIn(COutPoint(self.utxo[0].sha256, self.utxo[0].n), ""))
+        tx.vin.append(CTxIn(COutPoint(self.utxo[0].sha256, self.utxo[0].n), b""))
         tx.vout.append(CTxOut(self.utxo[0].nValue-1000, CScript([OP_TRUE])))
         tx.wit.vtxinwit.append(CTxinWitness())
-        tx.wit.vtxinwit[0].scriptWitness.stack = [ 'a' ]
+        tx.wit.vtxinwit[0].scriptWitness.stack = [ b'a' ]
         tx.rehash()
 
         tx_hash = tx.sha256
@@ -889,12 +888,12 @@ def test_tx_relay_after_segwit_activation(self):
         witness_hash = sha256(witness_program)
         scriptPubKey = CScript([OP_0, witness_hash])
         tx2 = CTransaction()
-        tx2.vin.append(CTxIn(COutPoint(tx_hash, 0), ""))
+        tx2.vin.append(CTxIn(COutPoint(tx_hash, 0), b""))
         tx2.vout.append(CTxOut(tx.vout[0].nValue-1000, scriptPubKey))
         tx2.rehash()
 
         tx3 = CTransaction()
-        tx3.vin.append(CTxIn(COutPoint(tx2.sha256, 0), ""))
+        tx3.vin.append(CTxIn(COutPoint(tx2.sha256, 0), b""))
         tx3.vout.append(CTxOut(tx2.vout[0].nValue-1000, CScript([OP_TRUE])))
         tx3.wit.vtxinwit.append(CTxinWitness())
         tx3.wit.vtxinwit[0].scriptWitness.stack = [CScript([CScriptNum(1)]), witness_program ]
@@ -995,8 +994,8 @@ def test_segwit_versions(self):
         NUM_TESTS = 17 # will test OP_0, OP1, ..., OP_16
         if (len(self.utxo) < NUM_TESTS):
             tx = CTransaction()
-            tx.vin.append(CTxIn(COutPoint(self.utxo[0].sha256, self.utxo[0].n), ""))
-            split_value = (self.utxo[0].nValue - 4000) / NUM_TESTS
+            tx.vin.append(CTxIn(COutPoint(self.utxo[0].sha256, self.utxo[0].n), b""))
+            split_value = (self.utxo[0].nValue - 4000) // NUM_TESTS
             for i in xrange(NUM_TESTS):
                 tx.vout.append(CTxOut(split_value, CScript([OP_TRUE])))
             tx.rehash()
@@ -1018,7 +1017,7 @@ def test_segwit_versions(self):
             count += 1
             # First try to spend to a future version segwit scriptPubKey.
             scriptPubKey = CScript([CScriptOp(version), witness_hash])
-            tx.vin = [CTxIn(COutPoint(self.utxo[0].sha256, self.utxo[0].n), "")]
+            tx.vin = [CTxIn(COutPoint(self.utxo[0].sha256, self.utxo[0].n), b"")]
             tx.vout = [CTxOut(self.utxo[0].nValue-1000, scriptPubKey)]
             tx.rehash()
             self.std_node.test_transaction_acceptance(tx, with_witness=True, accepted=False)
@@ -1034,7 +1033,7 @@ def test_segwit_versions(self):
         # are non-standard
         scriptPubKey = CScript([CScriptOp(OP_1), witness_hash])
         tx2 = CTransaction()
-        tx2.vin = [CTxIn(COutPoint(tx.sha256, 0), "")]
+        tx2.vin = [CTxIn(COutPoint(tx.sha256, 0), b"")]
         tx2.vout = [CTxOut(tx.vout[0].nValue-1000, scriptPubKey)]
         tx2.wit.vtxinwit.append(CTxinWitness())
         tx2.wit.vtxinwit[0].scriptWitness.stack = [ witness_program ]
@@ -1050,7 +1049,7 @@ def test_segwit_versions(self):
         tx3 = CTransaction()
         total_value = 0
         for i in temp_utxo:
-            tx3.vin.append(CTxIn(COutPoint(i.sha256, i.n), ""))
+            tx3.vin.append(CTxIn(COutPoint(i.sha256, i.n), b""))
             tx3.wit.vtxinwit.append(CTxinWitness())
             total_value += i.nValue
         tx3.wit.vtxinwit[-1].scriptWitness.stack = [witness_program]
@@ -1061,7 +1060,7 @@ def test_segwit_versions(self):
         self.test_node.test_transaction_acceptance(tx3, with_witness=True, accepted=False)
         self.test_node.sync_with_ping()
         with mininode_lock:
-            assert("reserved for soft-fork upgrades" in self.test_node.last_reject.reason)
+            assert(b"reserved for soft-fork upgrades" in self.test_node.last_reject.reason)
 
         # Building a block with the transaction must be valid, however.
         block = self.build_next_block()
@@ -1087,7 +1086,7 @@ def test_premature_coinbase_witness_spend(self):
         self.test_node.test_witness_block(block, accepted=True)
 
         spend_tx = CTransaction()
-        spend_tx.vin = [CTxIn(COutPoint(block.vtx[0].sha256, 0), "")]
+        spend_tx.vin = [CTxIn(COutPoint(block.vtx[0].sha256, 0), b"")]
         spend_tx.vout = [CTxOut(block.vtx[0].vout[0].nValue, witness_program)]
         spend_tx.wit.vtxinwit.append(CTxinWitness())
         spend_tx.wit.vtxinwit[0].scriptWitness.stack = [ witness_program ]
@@ -1111,7 +1110,7 @@ def test_premature_coinbase_witness_spend(self):
     def test_signature_version_1(self):
         print "\tTesting segwit signature hash version 1"
         key = CECKey()
-        key.set_secretbytes("9")
+        key.set_secretbytes(b"9")
         pubkey = CPubKey(key.get_pubkey())
 
         witness_program = CScript([pubkey, CScriptOp(OP_CHECKSIG)])
@@ -1121,7 +1120,7 @@ def test_signature_version_1(self):
         # First create a witness output for use in the tests.
         assert(len(self.utxo))
         tx = CTransaction()
-        tx.vin.append(CTxIn(COutPoint(self.utxo[0].sha256, self.utxo[0].n), ""))
+        tx.vin.append(CTxIn(COutPoint(self.utxo[0].sha256, self.utxo[0].n), b""))
         tx.vout.append(CTxOut(self.utxo[0].nValue-1000, scriptPubKey))
         tx.rehash()
 
@@ -1147,7 +1146,7 @@ def sign_P2PK_witness_input(script, txTo, inIdx, hashtype, value, key):
                 hashtype |= sigflag
                 block = self.build_next_block()
                 tx = CTransaction()
-                tx.vin.append(CTxIn(COutPoint(prev_utxo.sha256, prev_utxo.n), ""))
+                tx.vin.append(CTxIn(COutPoint(prev_utxo.sha256, prev_utxo.n), b""))
                 tx.vout.append(CTxOut(prev_utxo.nValue - 1000, scriptPubKey))
                 tx.wit.vtxinwit.append(CTxinWitness())
                 # Too-large input value
@@ -1178,7 +1177,7 @@ def sign_P2PK_witness_input(script, txTo, inIdx, hashtype, value, key):
         NUM_TESTS = 500
         temp_utxos = []
         tx = CTransaction()
-        tx.vin.append(CTxIn(COutPoint(prev_utxo.sha256, prev_utxo.n), ""))
+        tx.vin.append(CTxIn(COutPoint(prev_utxo.sha256, prev_utxo.n), b""))
         split_value = prev_utxo.nValue // NUM_TESTS
         for i in xrange(NUM_TESTS):
             tx.vout.append(CTxOut(split_value, scriptPubKey))
@@ -1203,7 +1202,7 @@ def sign_P2PK_witness_input(script, txTo, inIdx, hashtype, value, key):
             tx = CTransaction()
             total_value = 0
             for i in xrange(num_inputs):
-                tx.vin.append(CTxIn(COutPoint(temp_utxos[i].sha256, temp_utxos[i].n), ""))
+                tx.vin.append(CTxIn(COutPoint(temp_utxos[i].sha256, temp_utxos[i].n), b""))
                 tx.wit.vtxinwit.append(CTxinWitness())
                 total_value += temp_utxos[i].nValue
             split_value = total_value // num_outputs
@@ -1242,17 +1241,17 @@ def sign_P2PK_witness_input(script, txTo, inIdx, hashtype, value, key):
         pubkeyhash = hash160(pubkey)
         scriptPKH = CScript([OP_0, pubkeyhash])
         tx = CTransaction()
-        tx.vin.append(CTxIn(COutPoint(temp_utxos[0].sha256, temp_utxos[0].n), ""))
+        tx.vin.append(CTxIn(COutPoint(temp_utxos[0].sha256, temp_utxos[0].n), b""))
         tx.vout.append(CTxOut(temp_utxos[0].nValue, scriptPKH))
         tx.wit.vtxinwit.append(CTxinWitness())
         sign_P2PK_witness_input(witness_program, tx, 0, SIGHASH_ALL, temp_utxos[0].nValue, key)
         tx2 = CTransaction()
-        tx2.vin.append(CTxIn(COutPoint(tx.sha256, 0), ""))
+        tx2.vin.append(CTxIn(COutPoint(tx.sha256, 0), b""))
         tx2.vout.append(CTxOut(tx.vout[0].nValue, CScript([OP_TRUE])))
 
         script = CScript([CScriptOp(OP_DUP), CScriptOp(OP_HASH160), pubkeyhash, CScriptOp(OP_EQUALVERIFY), CScriptOp(OP_CHECKSIG)])
         sig_hash = SegwitVersion1SignatureHash(script, tx2, 0, SIGHASH_ALL, tx.vout[0].nValue)
-        signature = key.sign(sig_hash) + chr(SIGHASH_ALL)
+        signature = key.sign(sig_hash) + b'\x01' # 0x1 is SIGHASH_ALL
 
         # Check that we can't have a scriptSig
         tx2.vin[0].scriptSig = CScript([signature, pubkey])
@@ -1264,7 +1263,7 @@ def sign_P2PK_witness_input(script, txTo, inIdx, hashtype, value, key):
         block.vtx.pop()
         tx2.wit.vtxinwit.append(CTxinWitness())
         tx2.wit.vtxinwit[0].scriptWitness.stack = [signature, pubkey]
-        tx2.vin[0].scriptSig = ""
+        tx2.vin[0].scriptSig = b""
         tx2.rehash()
 
         self.update_witness_block_with_transactions(block, [tx2])
@@ -1280,7 +1279,7 @@ def sign_P2PK_witness_input(script, txTo, inIdx, hashtype, value, key):
             # Just spend to our usual anyone-can-spend output
             # Use SIGHASH_SINGLE|SIGHASH_ANYONECANPAY so we can build up
             # the signatures as we go.
-            tx.vin.append(CTxIn(COutPoint(i.sha256, i.n), ""))
+            tx.vin.append(CTxIn(COutPoint(i.sha256, i.n), b""))
             tx.vout.append(CTxOut(i.nValue, CScript([OP_TRUE])))
             tx.wit.vtxinwit.append(CTxinWitness())
             sign_P2PK_witness_input(witness_program, tx, index, SIGHASH_SINGLE|SIGHASH_ANYONECANPAY, i.nValue, key)
@@ -1309,7 +1308,7 @@ def test_p2sh_witness(self, segwit_activated):
 
         # Fund the P2SH output
         tx = CTransaction()
-        tx.vin.append(CTxIn(COutPoint(self.utxo[0].sha256, self.utxo[0].n), ""))
+        tx.vin.append(CTxIn(COutPoint(self.utxo[0].sha256, self.utxo[0].n), b""))
         tx.vout.append(CTxOut(self.utxo[0].nValue-1000, scriptPubKey))
         tx.rehash()
 
@@ -1334,7 +1333,7 @@ def test_p2sh_witness(self, segwit_activated):
         self.test_node.test_transaction_acceptance(spend_tx, with_witness=False, accepted=False)
 
         # Try to put the witness script in the scriptSig, should also fail.
-        spend_tx.vin[0].scriptSig = CScript([p2wsh_pubkey, 'a'])
+        spend_tx.vin[0].scriptSig = CScript([p2wsh_pubkey, b'a'])
         spend_tx.rehash()
         self.test_node.test_transaction_acceptance(spend_tx, with_witness=False, accepted=False)
 
@@ -1343,7 +1342,7 @@ def test_p2sh_witness(self, segwit_activated):
         spend_tx.vin[0].scriptSig = scriptSig
         spend_tx.rehash()
         spend_tx.wit.vtxinwit.append(CTxinWitness())
-        spend_tx.wit.vtxinwit[0].scriptWitness.stack = [ 'a', witness_program ]
+        spend_tx.wit.vtxinwit[0].scriptWitness.stack = [ b'a', witness_program ]
 
         # Verify mempool acceptance
         self.test_node.test_transaction_acceptance(spend_tx, with_witness=True, accepted=segwit_activated)
@@ -1431,7 +1430,7 @@ def test_witness_sigops(self):
         # First split our available utxo into a bunch of outputs
         split_value = self.utxo[0].nValue // outputs
         tx = CTransaction()
-        tx.vin.append(CTxIn(COutPoint(self.utxo[0].sha256, self.utxo[0].n), ""))
+        tx.vin.append(CTxIn(COutPoint(self.utxo[0].sha256, self.utxo[0].n), b""))
         for i in xrange(outputs):
             tx.vout.append(CTxOut(split_value, scriptPubKey))
         tx.vout[-2].scriptPubKey = scriptPubKey_toomany
@@ -1447,7 +1446,7 @@ def test_witness_sigops(self):
         # too many sigops.
         total_value = 0
         for i in xrange(outputs-1):
-            tx2.vin.append(CTxIn(COutPoint(tx.sha256, i), ""))
+            tx2.vin.append(CTxIn(COutPoint(tx.sha256, i), b""))
             tx2.wit.vtxinwit.append(CTxinWitness())
             tx2.wit.vtxinwit[-1].scriptWitness.stack = [ witness_program ]
             total_value += tx.vout[i].nValue
@@ -1488,7 +1487,7 @@ def test_witness_sigops(self):
         # output of tx
         block_5 = self.build_next_block()
         tx2.vout.pop()
-        tx2.vin.append(CTxIn(COutPoint(tx.sha256, outputs-1), ""))
+        tx2.vin.append(CTxIn(COutPoint(tx.sha256, outputs-1), b""))
         tx2.wit.vtxinwit.append(CTxinWitness())
         tx2.wit.vtxinwit[-1].scriptWitness.stack = [ witness_program_justright ]
         tx2.rehash()
diff --git a/qa/rpc-tests/segwit.py b/qa/rpc-tests/segwit.py
index 87e9cfdf3feb7..c3eea7be79c41 100755
--- a/qa/rpc-tests/segwit.py
+++ b/qa/rpc-tests/segwit.py
@@ -9,10 +9,9 @@
 
 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
@@ -20,33 +19,27 @@
 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 = {}
diff --git a/qa/rpc-tests/test_framework/blocktools.py b/qa/rpc-tests/test_framework/blocktools.py
index b24d72641ce9b..8724e1b0e1233 100644
--- a/qa/rpc-tests/test_framework/blocktools.py
+++ b/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.
diff --git a/qa/rpc-tests/test_framework/mininode.py b/qa/rpc-tests/test_framework/mininode.py
index c915cacc7542c..d6d6d057b889d 100755
--- a/qa/rpc-tests/test_framework/mininode.py
+++ b/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.
diff --git a/qa/rpc-tests/test_framework/script.py b/qa/rpc-tests/test_framework/script.py
index c446fda84f454..305a7f59b1a6b 100644
--- a/qa/rpc-tests/test_framework/script.py
+++ b/qa/rpc-tests/test_framework/script.py
@@ -911,19 +911,19 @@ 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))
@@ -931,7 +931,7 @@ def SegwitVersion1SignatureHash(script, txTo, inIdx, hashtype, amount):
         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)