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,
