def createLogEventFilter(eventName, contractAbi, fromAddress, web3, topicFilters:[]) -> (LogFilter, str): eventABI = filter_by_name(eventName, contractAbi)[0] eventSignature = abi_to_signature(eventABI) eventHash = bytes2Hex(web3.sha3(text = eventSignature)) l.debug('creating log filter. eventSignature:', eventSignature, 'eventHash:', eventHash, 'filters:',topicFilters) commandFilter = web3.eth.filter({'address': fromAddress, 'topics': [eventHash]+topicFilters}) return commandFilter, eventABI
def find_matching_fn_abi(abi, fn_identifier=None, args=None, kwargs=None): args = args or tuple() kwargs = kwargs or dict() filters = [] num_arguments = len(args) + len(kwargs) if fn_identifier is FallbackFn: return get_fallback_func_abi(abi) if not is_text(fn_identifier): raise TypeError("Unsupported function identifier") name_filter = functools.partial(filter_by_name, fn_identifier) arg_count_filter = functools.partial(filter_by_argument_count, num_arguments) encoding_filter = functools.partial(filter_by_encodability, args, kwargs) filters.extend([ name_filter, arg_count_filter, encoding_filter, ]) function_candidates = pipe(abi, *filters) if len(function_candidates) == 1: return function_candidates[0] else: matching_identifiers = name_filter(abi) matching_function_signatures = [ abi_to_signature(func) for func in matching_identifiers ] arg_count_matches = len(arg_count_filter(matching_identifiers)) encoding_matches = len(encoding_filter(matching_identifiers)) if arg_count_matches == 0: diagnosis = "\nFunction invocation failed due to improper number of arguments." elif encoding_matches == 0: diagnosis = "\nFunction invocation failed due to no matching argument types." elif encoding_matches > 1: diagnosis = ( "\nAmbiguous argument encoding. " "Provided arguments can be encoded to multiple functions matching this call." ) message = ( "\nCould not identify the intended function with name `{name}`, " "positional argument(s) of type `{arg_types}` and " "keyword argument(s) of type `{kwarg_types}`." "\nFound {num_candidates} function(s) with the name `{name}`: {candidates}" "{diagnosis}").format( name=fn_identifier, arg_types=tuple(map(type, args)), kwarg_types=valmap(type, kwargs), num_candidates=len(matching_identifiers), candidates=matching_function_signatures, diagnosis=diagnosis, ) raise ValidationError(message)
def contract_method_ID(methodname, abi): """ build the 4 byte ID, from abi & methodname """ method_abi = filter_by_name(methodname, abi) assert (len(method_abi) == 1) method_abi = method_abi[0] method_signature = abi_to_signature(method_abi) method_signature_hash_bytes = w3.sha3(text=method_signature) method_signature_hash_hex = w3.toHex(method_signature_hash_bytes) method_signature_hash_4bytes = method_signature_hash_hex[0:10] return method_signature_hash_4bytes
def compile_method_definition(contract_name, method_name, method): selector = encode_hex(function_abi_to_4byte_selector(method)) signature = abi_to_signature(method) data_asserts = generate_data_asserts(method).replace('\n', '\n' + 4 * ' ') assign_block = generate_assign_block(method).replace('\n', '\n' + 4 * ' ') try: data_len = compute_data_len(method) except UnsupportedDataType: data_len = None ret = compile_method_declaration(contract_name, method_name, method) if data_len is None: return ret + generate_unsupported_method() return ret + f'''