def test_apply_formatter_at_index(formatter, index, value, expected): if isinstance(expected, type) and issubclass(expected, Exception): with pytest.raises(expected): apply_formatter_at_index(formatter, index, value) with pytest.raises(expected): eth_utils.apply_formatter_at_index(formatter, index, value) else: assert eth_utils.apply_formatter_at_index(formatter, index, value) == expected # must be able to curry targetted_formatter = apply_formatter_at_index(formatter, index) assert targetted_formatter(value) == expected
def get_routing_table_bucket_info(self, bucket_index: int) -> BucketInfo: # TODO: normalize hex encoded node ids response = self.web3.manager.request_blocking( RPC.alexandria_routingTableBucketInfo, (bucket_index,), ) return BucketInfo(*apply_formatter_at_index( tuple, 3, apply_formatter_at_index( tuple, 2, response, ), ))
def middleware(method, params): if method in {'eth_sendTransaction', 'eth_estimateGas', 'eth_call'}: post_validated_params = apply_formatter_at_index( transaction_sanitizer, 0, params) return make_request(method, post_validated_params) else: return make_request(method, params)
class NewBlock(BaseCommand[NewBlockPayload]): protocol_command_id = 7 serialization_codec = RLPCodec(sedes=NEW_BLOCK_STRUCTURE, process_inbound_payload_fn=compose( lambda args: NewBlockPayload(*args), apply_formatter_at_index( lambda args: BlockFields(*args), 0, )))
class GetBlockHeaders(BaseCommand[GetBlockHeadersPayload]): protocol_command_id = 2 serialization_codec = RLPCodec( sedes=GET_BLOCK_HEADERS_STRUCTURE, process_inbound_payload_fn=compose( lambda args: GetBlockHeadersPayload(*args), apply_formatter_at_index(lambda args: BlockHeadersQuery(*args), 1)), )
def transaction_param_validator(web3): transactions_params_validators = { 'chainId': apply_formatter_if( # Bypass `validate_chain_id` if chainId can't be determined lambda _: is_not_null(web3.net.chainId), validate_chain_id(web3)), } return apply_formatter_at_index( apply_formatters_to_dict(transactions_params_validators), 0)
def _transaction_param_validator(web3_chain_id: int) -> Callable[..., Any]: transactions_params_validators = { "chainId": apply_formatter_if( # Bypass `validate_chain_id` if chainId can't be determined lambda _: is_not_null(web3_chain_id), _validate_chain_id(web3_chain_id), ), } return apply_formatter_at_index( apply_formatters_to_dict(transactions_params_validators), 0)
def abi_request_formatters(normalizers, abis): for method, abi_types in abis.items(): if isinstance(abi_types, list): yield method, map_abi_data(normalizers, abi_types) elif isinstance(abi_types, dict): single_dict_formatter = apply_abi_formatters_to_dict( normalizers, abi_types) yield method, apply_formatter_at_index(single_dict_formatter, 0) else: raise TypeError( "ABI definitions must be a list or dictionary, got %r" % abi_types)
class NewBlock(BaseCommand[NewBlockPayload]): protocol_command_id = 7 serialization_codec: RLPCodec[NewBlockPayload] = RLPCodec( sedes=sedes.List((sedes.List( (BlockHeader, sedes.CountableList(UninterpretedTransactionRLP), sedes.CountableList(BlockHeader))), sedes.big_endian_int)), process_inbound_payload_fn=compose( lambda args: NewBlockPayload(*args), apply_formatter_at_index( lambda args: BlockFields(*args), 0, )))
def transaction_param_validator(web3: "Web3") -> Callable[..., Any]: transactions_params_validators = { # type ignored b/c apply_formatter_if requires more args, but is_not_null is curried "chainId": apply_formatter_if( # type: ignore # Bypass `validate_chain_id` if chainId can't be determined lambda _: is_not_null(web3.eth.chainId), validate_chain_id(web3), ), } return apply_formatter_at_index( apply_formatters_to_dict(transactions_params_validators), 0)
class GetContractCodes(BaseCommand[GetContractCodesPayload]): protocol_command_id = 10 serialization_codec = RLPCodec( sedes=GET_CONTRACT_CODES_STRUCTURE, process_inbound_payload_fn=compose( lambda args: GetContractCodesPayload(*args), apply_formatter_at_index( apply_formatter_to_array( lambda args: ContractCodeRequest(*args)), 1, ), ), )
def abi_request_formatters( normalizers: Sequence[Callable[[TypeStr, Any], Tuple[TypeStr, Any]]], abis: Dict[RPCEndpoint, Any], ) -> Iterable[Tuple[RPCEndpoint, Callable[..., Any]]]: for method, abi_types in abis.items(): if isinstance(abi_types, list): yield method, map_abi_data(normalizers, abi_types) elif isinstance(abi_types, dict): single_dict_formatter = apply_abi_formatters_to_dict( normalizers, abi_types) yield method, apply_formatter_at_index(single_dict_formatter, 0) else: raise TypeError( f"ABI definitions must be a list or dictionary, got {abi_types!r}" )
Tuple[Dict[str, Any], int]] call_without_override = apply_formatters_to_sequence([ transaction_param_formatter, to_hex_if_integer, ]) call_with_override: Callable[ [Tuple[TxParams, BlockIdentifier, CallOverrideParams]], Tuple[Dict[str, Any], int, Dict[str, Any]], ] call_with_override = apply_formatters_to_sequence([ transaction_param_formatter, to_hex_if_integer, lambda x: x, ]) estimate_gas_without_block_id: Callable[[Dict[str, Any]], Dict[str, Any]] estimate_gas_without_block_id = apply_formatter_at_index( transaction_param_formatter, 0) estimate_gas_with_block_id: Callable[[Tuple[Dict[str, Any], Union[str, int]]], Tuple[Dict[str, Any], int]] estimate_gas_with_block_id = apply_formatters_to_sequence([ transaction_param_formatter, to_hex_if_integer, ]) SIGNED_TX_FORMATTER = { 'raw': HexBytes, 'tx': transaction_result_formatter, } signed_tx_formatter = apply_formatters_to_dict(SIGNED_TX_FORMATTER) FILTER_PARAM_NORMALIZERS = apply_formatters_to_dict(
def chain_id_validator(web3): return compose(apply_formatter_at_index(transaction_normalizer, 0), transaction_param_validator(web3))
filter_params_formatter = apply_formatters_to_dict(FILTER_PARAMS_FORMATTERS) filter_result_formatter = apply_one_of_formatters(( (is_array_of_dicts, apply_list_to_array_formatter(log_entry_formatter)), (is_array_of_strings, apply_list_to_array_formatter(to_hexbytes(32))), )) transaction_param_formatter = compose( remove_key_if('to', lambda txn: txn['to'] in {'', b'', None}), ) estimate_gas_without_block_id: Callable[[Dict[str, Any]], Dict[str, Any]] estimate_gas_without_block_id = apply_formatter_at_index(transaction_param_formatter, 0) estimate_gas_with_block_id: Callable[ [Tuple[Dict[str, Any], Union[str, int]]], Tuple[Dict[str, Any], int] ] estimate_gas_with_block_id = apply_formatters_to_sequence([ transaction_param_formatter, block_number_formatter, ]) SIGNED_TX_FORMATTER = { 'raw': HexBytes, 'tx': transaction_formatter, } signed_tx_formatter = apply_formatters_to_dict(SIGNED_TX_FORMATTER)
def get_routing_table_stats(self) -> RoutingTableStats: response = self.web3.manager.request_blocking(RPC.alexandria_routingTableStats, []) return RoutingTableStats(*apply_formatter_at_index(tuple, 3, response))
def _chain_id_validator(web3_chain_id: int) -> Callable[..., Any]: return compose(apply_formatter_at_index(_transaction_normalizer, 0), _transaction_param_validator(web3_chain_id))
def apply_formatters_to_args(*formatters: Callable[[TValue], TReturn]) -> Callable[..., TReturn]: return compose(*( apply_formatter_at_index(formatter, index) for index, formatter in enumerate(formatters) ))
def chain_id_validator(web3: "Web3") -> Callable[..., Any]: return compose(apply_formatter_at_index(transaction_normalizer, 0), transaction_param_validator(web3))
def apply_formatters_to_args(*formatters): return compose(*(apply_formatter_at_index(formatter, index) for index, formatter in enumerate(formatters)))
def middleware(method, params): if method in ('eth_sendTransaction', 'eth_estimateGas', 'eth_call'): post_validated_params = apply_formatter_at_index(transaction_sanitizer, 0, params) return make_request(method, post_validated_params) else: return make_request(method, params)
from eth_utils import ( is_string, ) from eth_utils.curried import ( apply_formatter_at_index, apply_formatter_if, apply_formatters_to_dict, ) from .formatting import ( construct_formatting_middleware, ) FILTER_PARAM_NORMALIZERS = apply_formatters_to_dict({ 'address': apply_formatter_if(is_string, lambda x: [x])}) METHOD_NORMALIZERS = { 'eth_getLogs': apply_formatter_at_index(FILTER_PARAM_NORMALIZERS, 0), 'eth_newFilter': apply_formatter_at_index(FILTER_PARAM_NORMALIZERS, 0) } request_parameter_normalizer = construct_formatting_middleware( request_formatters=METHOD_NORMALIZERS, )
FILTER_PARAMS_FORMATTERS = { 'fromBlock': apply_formatter_if(is_integer, integer_to_hex), 'toBlock': apply_formatter_if(is_integer, integer_to_hex), } filter_params_formatter = apply_formatters_to_dict(FILTER_PARAMS_FORMATTERS) filter_result_formatter = apply_one_of_formatters(( (is_array_of_dicts, apply_list_to_array_formatter(log_entry_formatter)), (is_array_of_strings, apply_list_to_array_formatter(to_hexbytes(32))), )) transaction_param_formatter = compose( remove_key_if('to', lambda txn: txn['to'] in {'', b'', None}), ) estimate_gas_without_block_id = apply_formatter_at_index( transaction_param_formatter, 0) estimate_gas_with_block_id = apply_formatters_to_sequence([ transaction_param_formatter, block_number_formatter, ]) pythonic_middleware = construct_formatting_middleware( request_formatters={ # Eth 'eth_getBalance': apply_formatter_at_index(block_number_formatter, 1), 'eth_getBlockByNumber': apply_formatter_at_index(block_number_formatter, 0), 'eth_getBlockTransactionCountByNumber': apply_formatter_at_index( block_number_formatter,