def null_if_excepts(exc_type: Type[BaseException],
fn: Callable[..., TReturn]) -> Callable[..., TReturn]:
return excepts(
exc_type,
fn,
static_return(None),
)
def _deserialize_kv_pairs(
cls,
serialized_enr: Sequence[bytes]) -> Iterable[Tuple[bytes, Any]]:
serialized_keys = serialized_enr[1::2]
serialized_values = serialized_enr[2::2]
keys = tuple(
binary.deserialize(serialized_key)
for serialized_key in serialized_keys)
cls._validate_key_uniqueness(keys, serialized_enr)
cls._validate_key_order(keys, serialized_enr)
value_deserializers = tuple(
ENR_KEY_SEDES_MAPPING.get(key, FALLBACK_ENR_VALUE_SEDES)
for key in keys)
values = tuple(
excepts(
DeserializationError,
value_deserializer.deserialize,
lambda v: FALLBACK_ENR_VALUE_SEDES.deserialize(serialized_value
),
)(serialized_value)
for value_deserializer, serialized_value in zip(
value_deserializers, serialized_values))
return dict(zip(keys, values))
def middleware(method: RPCEndpoint, params: Any) -> RPCResponse:
if method in method_handlers:
exc_type, handler = method_handlers[method]
return excepts(
exc_type,
make_request,
handler,
)(method, params)
else:
return make_request(method, params)
def middleware(method, params):
if method in method_handlers:
exc_type, handler = method_handlers[method]
return excepts(
exc_type,
make_request,
handler,
)(method, params)
else:
return make_request(method, params)
def highest_td_peer(self) -> BaseChainPeer:
peers = tuple(self.connected_nodes.values())
if not peers:
raise NoConnectedPeers("No connected peers")
td_getter = excepts(UnknownAPI,
operator.attrgetter('head_info.head_td'),
lambda _: 0)
peers_by_td = groupby(td_getter, peers)
max_td = max(peers_by_td.keys())
return random.choice(peers_by_td[max_td])
def _revert_pending_transaction_filter(self, filter):
is_valid_transaction_hash = excepts(
(TransactionNotFound,),
compose(
bool,
self.get_transaction_by_hash,
self.normalizer.normalize_outbound_transaction_hash,
),
lambda v: False,
)
values_to_remove = remove(is_valid_transaction_hash, filter.get_all())
filter.remove(*values_to_remove)
def _revert_block_filter(self, filter):
is_valid_block_hash = excepts(
(BlockNotFound,),
compose(
bool,
self.get_block_by_hash,
self.normalizer.normalize_outbound_block_hash,
),
lambda v: False,
)
values_to_remove = tuple(remove(is_valid_block_hash, filter.get_all()))
filter.remove(*values_to_remove)
def serialize(cls, enr: ENRAPI) -> Tuple[bytes, ...]:
serialized_sequence_number = big_endian_int.serialize(
enr.sequence_number)
sorted_key_value_pairs = sorted(enr.items(),
key=operator.itemgetter(0))
serialized_keys = tuple(
binary.serialize(key) for key, _ in sorted_key_value_pairs)
values_and_serializers = tuple(
(value, ENR_KEY_SEDES_MAPPING.get(key, FALLBACK_ENR_VALUE_SEDES))
for key, value in sorted_key_value_pairs)
serialized_values = tuple(
excepts(
(EncodingError, SerializationError),
value_serializer.serialize,
lambda v: FALLBACK_ENR_VALUE_SEDES.serialize(value),
)(value) for value, value_serializer in values_and_serializers)
return tuple(
cons(
serialized_sequence_number,
interleave((serialized_keys, serialized_values)),
))
not_implemented,
'compileSolidity':
not_implemented,
'compileSerpent':
not_implemented,
'newFilter':
create_log_filter,
'newBlockFilter':
call_eth_tester('create_block_filter'),
'newPendingTransactionFilter':
call_eth_tester('create_pending_transaction_filter'),
'uninstallFilter':
excepts(
FilterNotFound,
compose(
is_null,
call_eth_tester('delete_filter'),
),
static_return(False),
),
'getFilterChanges':
null_if_filter_not_found(call_eth_tester('get_only_filter_changes')),
'getFilterLogs':
null_if_filter_not_found(call_eth_tester('get_all_filter_logs')),
'getLogs':
get_logs,
'getWork':
not_implemented,
'submitWork':
not_implemented,
'submitHashrate':
not_implemented,
def null_if_excepts(exc_type, fn):
return excepts(
exc_type,
fn,
static_return(None),
)
