Merge pull request #323 from janx/abi-fixes

Abi fixes

Author: vbuterin

ethereum/abi.py

@@ -149,7 +149,7 @@ class ValueOutOfBounds(EncodingError):
 def decint(n):
     if isinstance(n, str):
         n = utils.to_string(n)
-    if is_numeric(n) and n < 2**256 and n > -2**255:
+    if is_numeric(n) and n < 2**256 and n >= -2**255:
         return n
     elif is_numeric(n):
         raise EncodingError("Number out of range: %r" % n)
@@ -186,21 +186,22 @@ def encode_single(typ, arg):
     elif base == 'int':
         sub = int(sub)
         i = decint(arg)
-        if not -2**(sub - 1) <= i < 2**sub:
+        if not -2**(sub - 1) <= i < 2**(sub - 1):
             raise ValueOutOfBounds(repr(arg))
         return zpad(encode_int(i % 2**sub), 32)
     # Unsigned reals: ureal<high>x<low>
     elif base == 'ureal':
         high, low = [int(x) for x in sub.split('x')]
         if not 0 <= arg < 2**high:
             raise ValueOutOfBounds(repr(arg))
-        return zpad(encode_int(arg * 2**low), 32)
+        return zpad(encode_int(int(arg * 2**low)), 32)
     # Signed reals: real<high>x<low>
     elif base == 'real':
         high, low = [int(x) for x in sub.split('x')]
         if not -2**(high - 1) <= arg < 2**(high - 1):
             raise ValueOutOfBounds(repr(arg))
-        return zpad(encode_int((arg % 2**high) * 2**low), 32)
+        i = int(arg * 2**low)
+        return zpad(encode_int(i % 2**(high+low)), 32)
     # Strings
     elif base == 'string' or base == 'bytes':
         if not is_string(arg):
@@ -221,9 +222,9 @@ def encode_single(typ, arg):
             raise EncodingError("too long: %r" % arg)
         if isnumeric(arg):
             return zpad(encode_int(arg), 32)
-        elif len(arg) == len(sub):
+        elif len(arg) == int(sub):
             return zpad(arg, 32)
-        elif len(arg) == len(sub) * 2:
+        elif len(arg) == int(sub) * 2:
             return zpad(decode_hex(arg), 32)
         else:
             raise EncodingError("Could not parse hash: %r" % arg)
@@ -236,7 +237,7 @@ def encode_single(typ, arg):
             return zpad(arg, 32)
         elif len(arg) == 40:
             return zpad(decode_hex(arg), 32)
-        elif len(arg) == 42 and arg[2:] == '0x':
+        elif len(arg) == 42 and arg[:2] == '0x':
             return zpad(decode_hex(arg[2:]), 32)
         else:
             raise EncodingError("Could not parse address: %r" % arg)
@@ -255,6 +256,8 @@ def process_type(typ):
     if base == 'string' or base == 'bytes':
         assert re.match('^[0-9]*$', sub), \
             "String type must have no suffix or numerical suffix"
+        assert not sub or int(sub) <= 32, \
+            "Maximum 32 bytes for fixed-length str or bytes"
     # Check validity of integer type
     elif base == 'uint' or base == 'int':
         assert re.match('^[0-9]+$', sub), \
@@ -263,12 +266,6 @@ def process_type(typ):
             "Integer size out of bounds"
         assert int(sub) % 8 == 0, \
             "Integer size must be multiple of 8"
-    # Check validity of string type
-    if base == 'string' or base == 'bytes':
-        assert re.match('^[0-9]*$', sub), \
-            "String type must have no suffix or numerical suffix"
-        assert not sub or int(sub) <= 32, \
-            "Maximum 32 bytes for fixed-length str or bytes"
     # Check validity of real type
     elif base == 'ureal' or base == 'real':
         assert re.match('^[0-9]+x[0-9]+$', sub), \
@@ -375,8 +372,14 @@ def decode_single(typ, data):
     base, sub, _ = typ
     if base == 'address':
         return encode_hex(data[12:])
-    elif base == 'string' or base == 'bytes' or base == 'hash':
-        return data[:int(sub)] if len(sub) else data
+    elif base == 'hash':
+        return data[32-int(sub):]
+    elif base == 'string' or base == 'bytes':
+        if len(sub):
+            return data[:int(sub)]
+        else:
+            l = big_endian_to_int(data[0:32])
+            return data[32:][:l]
     elif base == 'uint':
         return big_endian_to_int(data)
     elif base == 'int':
@@ -387,7 +390,9 @@ def decode_single(typ, data):
         return big_endian_to_int(data) * 1.0 / 2**low
     elif base == 'real':
         high, low = [int(x) for x in sub.split('x')]
-        return (big_endian_to_int(data) * 1.0 / 2**low) % 2**high
+        o = big_endian_to_int(data)
+        i = (o - 2**(high+low)) if o >= 2**(high+low-1) else o
+        return (i * 1.0 / 2**low)
     elif base == 'bool':
         return bool(int(data.encode('hex'), 16))
 

ethereum/tests/test_abi.py

@@ -1,7 +1,10 @@
 import os
+import pytest
 import ethereum.testutils as testutils
 from ethereum.slogging import get_logger
 import ethereum.abi as abi
+from ethereum.utils import zpad
+
 logger = get_logger()
 
 
@@ -17,6 +20,57 @@ def test_abi_encode_signed_int():
     assert abi.decode_abi(['int8'], abi.encode_abi(['int8'], [1]))[0] == 1
     assert abi.decode_abi(['int8'], abi.encode_abi(['int8'], [-1]))[0] == -1
 
+def test_abi_encode_single_int():
+    assert abi.encode_single(['int', '256', []], -2**255) == (b'\x80'+b'\x00'*31)
+
+    assert abi.encode_single(['int', '8', []], -128) == zpad(b'\x80', 32)
+    with pytest.raises(abi.ValueOutOfBounds):
+        assert abi.encode_single(['int', '8', []], -129)
+
+    assert abi.encode_single(['int', '8', []], 127) == zpad(b'\x7f', 32)
+    with pytest.raises(abi.ValueOutOfBounds):
+        assert abi.encode_single(['int', '8', []], 128)
+
+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', []], 2**127-1) == (b'\x7f' + b'\xff'*15 + b'\x00'*16)
+
+def test_abi_encode_single_real():
+    assert abi.encode_single(['real', '128x128', []], 1.125) == (b'\x00'*15 + b'\x01\x20' + b'\x00'*15)
+    assert abi.encode_single(['real', '128x128', []], -1.125) == (b'\xff'*15 + b'\xfe' + b'\xe0' + b'\x00'*15)
+
+def test_abi_encode_single_hash():
+    assert abi.encode_single(['hash', '8', []], b'\x00'*8) == b'\x00'*32
+    assert abi.encode_single(['hash', '8', []], '00'*8) == b'\x00'*32
+
+def test_abi_decode_single_hash():
+    typ = ['hash', '8', []]
+    assert b'\x01'*8 == abi.decode_single(typ, abi.encode_single(typ, b'\x01'*8))
+
+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'))
+
+    typ = ['bytes', '', []]
+    assert b'\x01\x02' == abi.decode_single(typ, abi.encode_single(typ, '\x01\x02'))
+
+def test_abi_encode_single_prefixed_address():
+    prefixed_address = '0x' + '0'*40
+    assert abi.encode_single(['address', '', []], prefixed_address) == b'\x00' * 32
+
+def test_abi_decode_single_real():
+    real_data = abi.encode_single(['real', '128x128', []], 1)
+    assert abi.decode_single(['real', '128x128', []], real_data) == 1
+
+    real_data = abi.encode_single(['real', '128x128', []], 2**127-1)
+    assert abi.decode_single(['real', '128x128', []], real_data) == (2**127-1)*1.0
+
+    real_data = abi.encode_single(['real', '128x128', []], -1)
+    assert abi.decode_single(['real', '128x128', []], real_data) == -1
+
+    real_data = abi.encode_single(['real', '128x128', []], -2**127)
+    assert abi.decode_single(['real', '128x128', []], real_data) == -2**127
 
 # Will be parametrized fron json fixtures
 def test_state(filename, testname, testdata):