added solidity_sha3()

Author: serderovsh

tronapi/base/abi.py

@@ -86,6 +86,7 @@
     "$"
 ).format(sub_type=SUB_TYPE_REGEX)
 
+
 def filter_by_argument_name(argument_names, contract_abi):
     return [
         abi
@@ -187,6 +188,19 @@ def get_abi_input_names(abi):
         return [arg['name'] for arg in abi['inputs']]
 
 
+def length_of_array_type(abi_type):
+    if not is_array_type(abi_type):
+        raise ValueError(
+            "Cannot parse length of nonarray abi-type: {0}".format(abi_type)
+        )
+
+    inner_brackets = re.search(END_BRACKETS_OF_ARRAY_TYPE_REGEX, abi_type).group(0).strip("[]")
+    if not inner_brackets:
+        return None
+    else:
+        return int(inner_brackets)
+
+
 def get_fallback_func_abi(contract_abi):
     fallback_abis = filter_by_type('fallback', contract_abi)
     if fallback_abis:
@@ -438,6 +452,7 @@ def normalizer(datatype, data):
     2. Recursively mapping each of the normalizers to the data
     3. Stripping the types back out of the tree
     """
+
     pipeline = itertools.chain(
         [abi_data_tree(types)],
         map(data_tree_map, normalizers),
@@ -448,7 +463,7 @@ def normalizer(datatype, data):
 
 
 @curry
-def abi_data_tree(types, data=None):
+def abi_data_tree(types, data):
     """Decorate the data tree with pairs of (type, data). The pair tuple is actually an
     ABITypedData, but can be accessed as a tuple.
 
@@ -458,6 +473,7 @@ def abi_data_tree(types, data=None):
     Returns:
         [("bool[2]", [("bool", True), ("bool", False)]), ("uint256", 0)]
     """
+
     return [
         abi_sub_tree(data_type, data_value)
         for data_type, data_value

tronapi/base/encoding.py

@@ -11,6 +11,9 @@
     int_to_big_endian
 )
 
+from tronapi.base.abi import size_of_type, sub_type_of_array_type, is_array_type, is_bool_type, is_uint_type, \
+    is_int_type, is_address_type, is_bytes_type, is_string_type
+from tronapi.base.validation import validate_abi_type, validate_abi_value
 from tronapi.utils.hexadecimal import (
     remove_0x_prefix,
     decode_hex,
@@ -25,13 +28,45 @@
 from tronapi.utils.types import (
     is_boolean,
     is_integer,
-    is_list_like
-)
+    is_list_like,
+    is_bytes)
 
 from tronapi.base.datastructures import AttributeDict
 from tronapi.utils.validation import assert_one_val
 
 
+def hex_encode_abi_type(abi_type, value, force_size=None):
+    """
+    Encodes value into a hex string in format of abi_type
+    """
+    validate_abi_type(abi_type)
+    validate_abi_value(abi_type, value)
+
+    data_size = force_size or size_of_type(abi_type)
+    if is_array_type(abi_type):
+        sub_type = sub_type_of_array_type(abi_type)
+        return "".join([remove_0x_prefix(hex_encode_abi_type(sub_type, v, 256)) for v in value])
+    elif is_bool_type(abi_type):
+        return to_hex_with_size(value, data_size)
+    elif is_uint_type(abi_type):
+        return to_hex_with_size(value, data_size)
+    elif is_int_type(abi_type):
+        return to_hex_twos_compliment(value, data_size)
+    elif is_address_type(abi_type):
+        return pad_hex(value, data_size)
+    elif is_bytes_type(abi_type):
+        if is_bytes(value):
+            return encode_hex(value)
+        else:
+            return value
+    elif is_string_type(abi_type):
+        return to_hex(text=value)
+    else:
+        raise ValueError(
+            "Unsupported ABI type: {0}".format(abi_type)
+        )
+
+
 def to_hex_twos_compliment(value, bit_size):
     """
     Converts integer value to twos compliment hex representation with given bit_size

tronapi/base/normalizers.py

@@ -1,8 +1,10 @@
 import functools
 import json
 
+
 from eth_utils import is_binary_address, to_hex, hexstr_if_str
 from hexbytes import HexBytes
+from toolz import curry
 
 from tronapi.base.abi import process_type
 from tronapi.base.encoding import to_bytes, text_if_str, to_text
@@ -55,3 +57,8 @@ def abi_bytes_to_bytes(abi_type, data):
     base, sub, arrlist = process_type(abi_type)
     if base == 'bytes' and not arrlist:
         return abi_type, hexstr_if_str(to_bytes, data)
+
+
+@curry
+def abi_resolver(abi_type, val):
+    return abi_type, val

tronapi/main.py

@@ -18,14 +18,17 @@
 import ecdsa
 from eth_utils import apply_to_return_value, to_hex
 from hexbytes import HexBytes
+from tronapi.base.abi import map_abi_data
 
 from tronapi.base.account import Account, PrivateKey
 from tronapi.base.datastructures import AttributeDict
+from tronapi.base.normalizers import abi_resolver
 from tronapi.base.encoding import (
     to_bytes,
     to_int,
     to_text,
-    to_json
+    to_json,
+    hex_encode_abi_type
 )
 
 from tronapi.exceptions import InvalidTronError, TronError
@@ -36,6 +39,7 @@
 from tronapi.base.validation import is_address
 from tronapi.utils.crypto import keccak
 from tronapi.utils.currency import to_sun, from_sun
+from tronapi.utils.hexadecimal import remove_0x_prefix, add_0x_prefix
 from tronapi.utils.types import is_integer
 
 DEFAULT_MODULES = {
@@ -268,6 +272,37 @@ def is_valid_provider(provider) -> bool:
         """
         return isinstance(provider, HttpProvider)
 
+    def solidity_sha3(self, abi_types, values):
+        """
+            Executes keccak256 exactly as Solidity does.
+            Takes list of abi_types as inputs -- `[uint24, int8[], bool]`
+            and list of corresponding values  -- `[20, [-1, 5, 0], True]`
+
+            Args:
+                abi_types (any): types abi
+                values (any): values
+
+            Examples:
+                >>> tron = Tron()
+                >>> sol = tron.solidity_sha3(['uint8[]'], [[1, 2, 3, 4, 5]])
+                >>> assert sol.hex() == '0x5917e5a395fb9b454434de59651d36822a9e29c5ec57474df3e67937b969460c'
+
+        """
+        if len(abi_types) != len(values):
+            raise ValueError(
+                "Length mismatch between provided abi types and values.  Got "
+                "{0} types and {1} values.".format(len(abi_types), len(values))
+            )
+
+        normalized_values = map_abi_data([abi_resolver()], abi_types, values)
+
+        hex_string = add_0x_prefix(''.join(
+            remove_0x_prefix(hex_encode_abi_type(abi_type, value))
+            for abi_type, value
+            in zip(abi_types, normalized_values)
+        ))
+        return self.sha3(hexstr=hex_string)
+
     @staticmethod
     @apply_to_return_value(HexBytes)
     def sha3(primitive=None, text=None, hexstr=None):