Piper/serenity

ethereum/abi.py

@@ -1,11 +1,11 @@
 import sys
 import re
 import yaml  # use yaml instead of json to get non unicode (works with ascii only data)
-from ethereum import utils
+import utils
 from rlp.utils import decode_hex, encode_hex
-from ethereum.utils import encode_int, zpad, big_endian_to_int, is_numeric, is_string, ceil32
-from ethereum.utils import isnumeric
+from utils import encode_int, zpad, big_endian_to_int, is_numeric, is_string, ceil32, ADDR_BYTES, isnumeric
 import ast
+import copy
 
 
 def json_decode(x):
@@ -100,24 +100,24 @@ def decode(self, name, data):
     def is_unknown_type(self, name):
         return self.function_data[name]["is_unknown_type"]
 
-    def listen(self, log, noprint=False):
-        if not len(log.topics) or log.topics[0] not in self.event_data:
+    def listen(self, sender, topics, data, noprint=False):
+        if not len(topics) or topics[0] not in self.event_data:
             return
-        types = self.event_data[log.topics[0]]['types']
-        name = self.event_data[log.topics[0]]['name']
-        names = self.event_data[log.topics[0]]['names']
-        indexed = self.event_data[log.topics[0]]['indexed']
+        types = self.event_data[topics[0]]['types']
+        name = self.event_data[topics[0]]['name']
+        names = self.event_data[topics[0]]['names']
+        indexed = self.event_data[topics[0]]['indexed']
         indexed_types = [types[i] for i in range(len(types))
                          if indexed[i]]
         unindexed_types = [types[i] for i in range(len(types))
                            if not indexed[i]]
         # print('listen', log.data.encode('hex'), log.topics)
-        deserialized_args = decode_abi(unindexed_types, log.data)
+        deserialized_args = decode_abi(unindexed_types, data)
         o = {}
         c1, c2 = 0, 0
         for i in range(len(names)):
             if indexed[i]:
-                topic_bytes = utils.zpad(utils.encode_int(log.topics[c1 + 1]), 32)
+                topic_bytes = utils.zpad(utils.encode_int(topics[c1 + 1]), 32)
                 o[names[i]] = decode_single(process_type(indexed_types[c1]),
                                             topic_bytes)
                 c1 += 1
@@ -153,7 +153,7 @@ def decint(n):
         return n
     elif is_numeric(n):
         raise EncodingError("Number out of range: %r" % n)
-    elif is_string(n) and len(n) == 40:
+    elif is_string(n) and len(n) == ADDR_BYTES * 2:
         return big_endian_to_int(decode_hex(n))
     elif is_string(n) and len(n) <= 32:
         return big_endian_to_int(n)
@@ -232,39 +232,38 @@ def encode_single(typ, arg):
         assert sub == ''
         if isnumeric(arg):
             return zpad(encode_int(arg), 32)
-        elif len(arg) == 20:
+        elif len(arg) == ADDR_BYTES:
             return zpad(arg, 32)
-        elif len(arg) == 40:
+        elif len(arg) == ADDR_BYTES * 2:
             return zpad(decode_hex(arg), 32)
-        elif len(arg) == 42 and arg[2:] == '0x':
+        elif len(arg) == ADDR_BYTES * 2 + 2 and arg[2:] == '0x':
             return zpad(decode_hex(arg[2:]), 32)
         else:
             raise EncodingError("Could not parse address: %r" % arg)
     raise EncodingError("Unhandled type: %r %r" % (base, sub))
 
+proctype_cache = {}
 
 def process_type(typ):
+    if typ in proctype_cache:
+        return proctype_cache[typ]
     # Crazy reg expression to separate out base type component (eg. uint),
     # size (eg. 256, 128x128, none), array component (eg. [], [45], none)
     regexp = '([a-z]*)([0-9]*x?[0-9]*)((\[[0-9]*\])*)'
     base, sub, arr, _ = re.match(regexp, utils.to_string_for_regexp(typ)).groups()
     arrlist = re.findall('\[[0-9]*\]', arr)
     assert len(''.join(arrlist)) == len(arr), \
         "Unknown characters found in array declaration"
-    # 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"
     # Check validity of integer type
-    elif base == 'uint' or base == 'int':
+    if base == 'uint' or base == 'int':
         assert re.match('^[0-9]+$', sub), \
             "Integer type must have numerical suffix"
         assert 8 <= int(sub) <= 256, \
             "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':
+    elif 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, \
@@ -285,7 +284,9 @@ def process_type(typ):
     # Check validity of address type
     elif base == 'address':
         assert sub == '', "Address cannot have suffix"
-    return base, sub, [ast.literal_eval(x) for x in arrlist]
+    o = base, sub, [ast.literal_eval(x) for x in arrlist]
+    proctype_cache[typ] = o
+    return o
 
 
 # Returns the static size of a type, or None if dynamic
@@ -374,7 +375,7 @@ def encode_abi(types, args):
 def decode_single(typ, data):
     base, sub, _ = typ
     if base == 'address':
-        return encode_hex(data[12:])
+        return encode_hex(data[32-ADDR_BYTES:])
     elif base == 'string' or base == 'bytes' or base == 'hash':
         return data[:int(sub)] if len(sub) else data
     elif base == 'uint':
@@ -392,8 +393,13 @@ def decode_single(typ, data):
         return bool(int(data.encode('hex'), 16))
 
 
+decode_abi_cache = {}
+
 # Decodes multiple arguments using the head/tail mechanism
 def decode_abi(types, data):
+    cache_key = str(types) + data
+    if cache_key in decode_abi_cache:
+        return copy.deepcopy(decode_abi_cache[cache_key])
     # Process types
     proctypes = [process_type(typ) for typ in types]
     # Get sizes of everything
@@ -431,7 +437,9 @@ def decode_abi(types, data):
             next_offset = start_positions[i + 1]
             outs[i] = data[offset:next_offset]
     # Recursively decode them all
-    return [dec(proctypes[i], outs[i]) for i in range(len(outs))]
+    o = [dec(proctypes[i], outs[i]) for i in range(len(outs))]
+    decode_abi_cache[cache_key] = copy.deepcopy(o)
+    return o
 
 
 # Decode a single value (static or dynamic)