string and bytes compat

Author: pipermerriam

ethereum/_solidity.py

@@ -6,6 +6,9 @@
 
 import yaml
 
+from rlp.utils import decode_hex
+from . import utils
+
 BINARY = 'solc'
 
 
@@ -49,7 +52,7 @@ def solc_arguments(libraries=None, combined='bin,abi', optimize=True):
 
     if libraries is not None and len(libraries):
         addresses = [
-            '{name}:{address}'.format(name=name, address=address)
+            '{name}:{address}'.format(name=name, address=address.decode('utf8'))
             for name, address in libraries.items()
         ]
         args.extend([

ethereum/chain.py

@@ -110,7 +110,7 @@ class Chain(object):
     """
     head_candidate = None
 
-    def __init__(self, env, genesis=None, new_head_cb=None, coinbase='\x00' * 20):
+    def __init__(self, env, genesis=None, new_head_cb=None, coinbase=b'\x00' * 20):
         assert isinstance(env, Env)
         self.env = env
         self.db = self.blockchain = env.db

ethereum/ethash.py

@@ -9,7 +9,7 @@
     from functools import lru_cache
 
 
-cache_seeds = ['\x00' * 32]
+cache_seeds = [b'\x00' * 32]
 
 
 def mkcache(block_number):

ethereum/ethpow.py

@@ -69,9 +69,9 @@ def check_pow(block_number, header_hash, mixhash, nonce, difficulty):
     # Grab current cache
     cache = get_cache(block_number)
     mining_output = hashimoto_light(block_number, cache, header_hash, nonce)
-    if mining_output['mix digest'] != mixhash:
+    if mining_output[b'mix digest'] != mixhash:
         return False
-    return utils.big_endian_to_int(mining_output['result']) <= 2**256 / (difficulty or 1)
+    return utils.big_endian_to_int(mining_output[b'result']) <= 2**256 / (difficulty or 1)
 
 
 class Miner():
@@ -114,9 +114,9 @@ def mine(block_number, difficulty, mining_hash, start_nonce=0, rounds=1000):
     for i in range(1, rounds + 1):
         bin_nonce = utils.zpad(utils.int_to_big_endian((nonce + i) & TT64M1), 8)
         o = hashimoto_light(block_number, cache, mining_hash, bin_nonce)
-        if o["result"] <= target:
+        if o[b"result"] <= target:
             log.debug("nonce found")
             assert len(bin_nonce) == 8
-            assert len(o["mix digest"]) == 32
-            return bin_nonce, o["mix digest"]
+            assert len(o[b"mix digest"]) == 32
+            return bin_nonce, o[b"mix digest"]
     return None, None

ethereum/keys.py

@@ -239,7 +239,7 @@ def big_endian_to_int(value):
         if len(value) == 1:
             return ord(value)
         elif len(value) <= 8:
-            return struct.unpack('>Q', value.rjust(8, '\x00'))[0]
+            return struct.unpack('>Q', value.rjust(8, b'\x00'))[0]
         else:
             return int(encode_hex(value), 16)
 

ethereum/tests/test_abi.py

@@ -34,7 +34,7 @@ def test_abi_encode_single_int():
 
 def test_abi_encode_single_ureal():
     assert abi.encode_single(['ureal', '128x128', []], 0) == (b'\x00'*32)
-    assert abi.encode_single(['ureal', '128x128', []], 1.125) == (b'\x00'*15 + b'\x01\x20' + '\x00'*15)
+    assert abi.encode_single(['ureal', '128x128', []], 1.125) == (b'\x00'*15 + b'\x01\x20' + b'\x00'*15)
     assert abi.encode_single(['ureal', '128x128', []], 2**127-1) == (b'\x7f' + b'\xff'*15 + b'\x00'*16)
 
 def test_abi_encode_single_real():
@@ -51,10 +51,10 @@ def test_abi_decode_single_hash():
 
 def test_abi_decode_single_bytes():
     typ = ['bytes', '8', []]
-    assert (b'\x01\x02' + b'\x00'*6) == abi.decode_single(typ, abi.encode_single(typ, '\x01\x02'))
+    assert (b'\x01\x02' + b'\x00'*6) == abi.decode_single(typ, abi.encode_single(typ, b'\x01\x02'))
 
     typ = ['bytes', '', []]
-    assert b'\x01\x02' == abi.decode_single(typ, abi.encode_single(typ, '\x01\x02'))
+    assert b'\x01\x02' == abi.decode_single(typ, abi.encode_single(typ, b'\x01\x02'))
 
 def test_abi_encode_single_prefixed_address():
     prefixed_address = '0x' + '0'*40

ethereum/tests/test_contracts.py

@@ -1207,8 +1207,8 @@ def test_ecrecover():
     signature = pk.ecdsa_recoverable_serialize(
         pk.ecdsa_sign_recoverable(msghash, raw=True)
     )
-    signature = signature[0] + chr(signature[1])
-    V = ord(signature[64]) + 27
+    signature = signature[0] + utils.bytearray_to_bytestr([signature[1]])
+    V = utils.safe_ord(signature[64]) + 27
     R = big_endian_to_int(signature[0:32])
     S = big_endian_to_int(signature[32:64])
 
@@ -1629,9 +1629,15 @@ def test_string_logging():
     o = []
     s.block.log_listeners.append(lambda x: o.append(c.translator.listen(x)))
     c.moo()
-    assert o == [{"_event_type": "foo", "x": "bob", "__hash_x": utils.sha3("bob"),
-                  "y": "cow", "__hash_y": utils.sha3("cow"), "z": "dog",
-                  "__hash_z": utils.sha3("dog")}]
+    assert o == [{
+        "_event_type": b"foo",
+        "x": b"bob",
+        "__hash_x": utils.sha3(b"bob"),
+        "y": b"cow",
+        "__hash_y": utils.sha3(b"cow"),
+        "z": b"dog",
+        "__hash_z": utils.sha3(b"dog"),
+    }]
 
 
 params_code = """
@@ -1654,7 +1660,7 @@ def test_params_contract():
     s = tester.state()
     c = s.abi_contract(params_code, FOO=4, BAR='horse')
     assert c.garble() == 4
-    assert c.marble() == 'horse'
+    assert c.marble() == b'horse'
 
 prefix_types_in_functions_code = """
 type fixedp: fp_

ethereum/testutils.py

@@ -67,7 +67,7 @@ def acct_standard_form(a):
         "nonce": parse_int_or_hex(a["nonce"]),
         "code": to_string(a["code"]),
         "storage": {normalize_hex(k): normalize_hex(v) for
-                    k, v in a["storage"].items() if normalize_hex(v).rstrip('0') != '0x'}
+                    k, v in a["storage"].items() if normalize_hex(v).rstrip(b'0') != b'0x'}
     }
 
 

ethereum/transactions.py

@@ -87,7 +87,7 @@ def sender(self):
                     pk.public_key = pk.ecdsa_recover(
                         rawhash,
                         pk.ecdsa_recoverable_deserialize(
-                            zpad("".join(chr(c) for c in int_to_32bytearray(self.r)), 32) + zpad("".join(chr(c) for c in int_to_32bytearray(self.s)), 32),
+                            zpad(utils.bytearray_to_bytestr(int_to_32bytearray(self.r)), 32) + zpad(utils.bytearray_to_bytestr(int_to_32bytearray(self.s)), 32),
                             self.v - 27
                         ),
                         raw=True
@@ -96,7 +96,7 @@ def sender(self):
                 except Exception:
                     raise InvalidTransaction("Invalid signature values (x^3+7 is non-residue)")
 
-                if pub[1:] == "\x00" * 32:
+                if pub[1:] == b"\x00" * 32:
                     raise InvalidTransaction("Invalid signature (zero privkey cannot sign)")
                 pub = encode_pubkey(pub, 'bin')
                 self._sender = utils.sha3(pub[1:])[-20:]
@@ -114,7 +114,7 @@ def sign(self, key):
 
         A potentially already existing signature would be overridden.
         """
-        if key in (0, '', '\x00' * 32, '0' * 64):
+        if key in (0, '', b'\x00' * 32, '0' * 64):
             raise InvalidTransaction("Zero privkey cannot sign")
         rawhash = utils.sha3(rlp.encode(self, UnsignedTransaction))
 
@@ -126,8 +126,8 @@ def sign(self, key):
         signature = pk.ecdsa_recoverable_serialize(
             pk.ecdsa_sign_recoverable(rawhash, raw=True)
         )
-        signature = signature[0] + chr(signature[1])
-        self.v = ord(signature[64]) + 27
+        signature = signature[0] + utils.bytearray_to_bytestr([signature[1]])
+        self.v = utils.safe_ord(signature[64]) + 27
         self.r = big_endian_to_int(signature[0:32])
         self.s = big_endian_to_int(signature[32:64])
 

ethereum/utils.py

@@ -35,6 +35,9 @@ def to_string_for_regexp(value):
         return str(value)
     unicode = unicode
 
+    def bytearray_to_bytestr(value):
+        return bytes(''.join(chr(c) for c in value))
+
 else:
     is_numeric = lambda x: isinstance(x, int)
     is_string = lambda x: isinstance(x, bytes)
@@ -56,6 +59,9 @@ def to_string_for_regexp(value):
         return str(to_string(value), 'utf-8')
     unicode = str
 
+    def bytearray_to_bytestr(value):
+        return bytes(value)
+
 isnumeric = is_numeric
 
 
@@ -110,7 +116,8 @@ def int_to_32bytearray(i):
 def sha3(seed):
     sha3_count[0] += 1
     return sha3_256(to_string(seed))
-assert sha3('').encode('hex') == 'c5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470'
+
+assert encode_hex(sha3('')) == b'c5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470'
 
 
 def privtoaddr(x, extended=False):
@@ -136,7 +143,7 @@ def check_and_strip_checksum(x):
 
 
 def normalize_address(x, allow_blank=False):
-    if allow_blank and x == '':
+    if allow_blank and (x == '' or x == b''):
         return ''
     if len(x) in (42, 50) and x[:2] == '0x':
         x = x[2:]
@@ -156,7 +163,7 @@ def zpad(x, l):
 
 def zunpad(x):
     i = 0
-    while i < len(x) and (x[i] == 0 or x[i] == '\x00'):
+    while i < len(x) and (x[i] == 0 or x[i] == b'\x00'):
         i += 1
     return x[i:]
 
@@ -247,7 +254,7 @@ def decode_addr(v):
 
 def decode_int(v):
     '''decodes and integer from serialization'''
-    if len(v) > 0 and (v[0] == '\x00' or v[0] == 0):
+    if len(v) > 0 and (v[0] == b'\x00' or v[0] == 0):
         raise Exception("No leading zero bytes allowed for integers")
     return big_endian_to_int(v)