def topic_from_event_name_static(abifile, name):
dp = DatatypeParser()
dp.load_abi_file(abifile)
abi = dp.event_name_map[name]
# print(abi)
v = event_abi_to_log_topic(abi)
return encode_hex(v)
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 encode_abi(abi, arguments, data=None):
argument_types = get_abi_input_types(abi)
if not check_if_arguments_can_be_encoded(abi, arguments, {}):
raise TypeError(
"One or more arguments could not be encoded to the necessary "
"ABI type. Expected types are: {0}".format(
', '.join(argument_types), ))
normalizers = [
abi_address_to_hex,
abi_bytes_to_bytes,
abi_string_to_text,
]
normalized_arguments = map_abi_data(
normalizers,
argument_types,
arguments,
)
encoded_arguments = eth_abi_encode_abi(
argument_types,
normalized_arguments,
)
if data:
return to_hex(HexBytes(data) + encoded_arguments)
else:
return encode_hex(encoded_arguments)
def to_4byte_hex(hex_or_str_or_bytes):
size_of_4bytes = 4 * 8
byte_str = hexstr_if_str(to_bytes, hex_or_str_or_bytes)
if len(byte_str) > 4:
raise ValueError(
'expected value of size 4 bytes. Got: %d bytes' % len(byte_str)
)
hex_str = encode_hex(byte_str)
return pad_hex(hex_str, size_of_4bytes)
def parse_abi(self):
'''for item in self.contract_abi:
if (item["type"] != "constructor"):
print(item["name"], " is a ", item["type"])
hash4 = function_signature_to_4byte_selector(item["name"] + '()')
print("function hash4:", encode_hex(hash4))'''
funclist = filter_by_type("function", self.contract_abi)
for func in funclist:
signature = abi_to_signature(func)
selector = function_signature_to_4byte_selector(signature)
# print(func)
# print(signature)
# print(encode_hex(selector) )
self.func_abi_map_by_selector[encode_hex(selector)] = func
self.func_abi_map_by_name[func['name']] = func
eventlist = filter_by_type("event", self.contract_abi)
for event in eventlist:
topic = event_abi_to_log_topic(event)
# print(event)
# print(encode_hex(topic) )
event['topic'] = encode_hex(topic)
self.event_topic_map[encode_hex(topic)] = event
self.event_name_map[event["name"]] = event
def get_function_info(fn_name,
contract_abi=None,
fn_abi=None,
args=None,
kwargs=None):
if args is None:
args = tuple()
if kwargs is None:
kwargs = {}
if fn_abi is None:
fn_abi = find_matching_fn_abi(contract_abi, fn_name, args, kwargs)
fn_selector = encode_hex(function_abi_to_4byte_selector(fn_abi))
fn_arguments = merge_args_and_kwargs(fn_abi, args, kwargs)
_, aligned_fn_arguments = get_aligned_abi_inputs(fn_abi, fn_arguments)
return fn_abi, fn_selector, aligned_fn_arguments
def topic_from_event_name(self, name):
abi = self.event_name_map[name]
v = event_abi_to_log_topic(abi)
return encode_hex(v)
def topic_from_string(value):
s = encode_hex(keccak(bytes(value, "utf-8")))[2:]
return "0x" + s
def get_fallback_function_info(contract_abi=None, fn_abi=None):
if fn_abi is None:
fn_abi = get_fallback_func_abi(contract_abi)
fn_selector = encode_hex(b'')
fn_arguments = tuple()
return fn_abi, fn_selector, fn_arguments