def test_skale_filter(skale):
sfilter = SkaleFilter(
skale.dkg.contract.events.BroadcastAndKeyShare,
from_block=0,
argument_filters={}
)
assert isinstance(sfilter.get_events(), list)
def schains_cleaner(self, opts):
schains_on_node = self.get_schains_on_node()
schain_ids = self.schain_names_to_ids(schains_on_node)
schain_names_on_contracts = self.get_schain_names_from_contract()
event_filter = SkaleFilter(
self.skale_events.schains.contract.events.SchainDeleted,
from_block=0,
argument_filters={'schainId': schain_ids})
events = event_filter.get_events()
for event in events:
name = event['args']['name']
if name in schains_on_node and name not in schain_names_on_contracts:
logger.info(
arguments_list_string({'sChain name': name},
'sChain deleted event found'))
self.run_cleanup(name)
def get_dkg_complaint_sent_filter(skale,
group_index,
to_node_index,
from_block=0):
return SkaleFilter(skale.dkg.contract.events.ComplaintSent,
from_block=from_block,
argument_filters={
'groupIndex': group_index,
'toNodeIndex': to_node_index
})
def test_remove_schain_filter(skale):
for _ in range(0, 1):
ip, _, port, name = generate_random_node_data()
skale.manager.create_node(ip, port, name, wait_for=True)
sfilter = SkaleFilter(
skale.schains.contract.events.SchainCreated,
from_block=0,
argument_filters={}
)
type_of_nodes, lifetime_seconds, name = generate_random_schain_data()
price_in_wei = skale.schains.get_schain_price(type_of_nodes,
lifetime_seconds)
tx_res = skale.manager.create_schain(lifetime_seconds, type_of_nodes,
price_in_wei, name, wait_for=True)
assert tx_res.receipt['status'] == 1
events = sfilter.get_events()
assert events[-1]['args']['name'] == name
def get_metrics_from_events(start_date=None,
end_date=None,
limit=None,
wei=None):
metrics_rows = []
total_bounty = 0
limit = format_limit(limit)
start_block_number, last_block_number = get_start_end_block_numbers(
start_date, end_date)
start_chunk_block_number = start_block_number
while len(metrics_rows) < limit:
end_chunk_block_number = start_chunk_block_number + BLOCK_CHUNK_SIZE - 1
if end_chunk_block_number > last_block_number:
end_chunk_block_number = last_block_number
event_filter = SkaleFilter(
skale.manager.contract.events.BountyGot,
from_block=hex(start_chunk_block_number),
argument_filters={'nodeIndex': config.id},
to_block=hex(end_chunk_block_number))
logs = event_filter.get_events()
for log in logs:
args = log['args']
tx_block_number = log['blockNumber']
block_data = skale.web3.eth.getBlock(tx_block_number)
block_timestamp = datetime.utcfromtimestamp(
block_data['timestamp'])
bounty = args['bounty']
if not wei:
bounty = to_skl(bounty)
metrics_row = [
str(block_timestamp), bounty, args['averageDowntime'],
round(args['averageLatency'] / 1000, 1)
]
total_bounty += metrics_row[1]
metrics_rows.append(metrics_row)
if len(metrics_rows) >= limit:
break
start_chunk_block_number = start_chunk_block_number + BLOCK_CHUNK_SIZE
if end_chunk_block_number >= last_block_number:
break
return metrics_rows, total_bounty
def test_skale_filter_with_events(skale):
events = [{'event_id': 1}, {'event_id': 2}]
def create_filter_mock(*, fromBlock=0, toBlock=0, argument_filters={}):
cf_mock = mock.Mock()
cf_mock.get_all_entries = mock.Mock(
return_value=events
)
return cf_mock
with mock.patch.object(
skale.dkg.contract.events.BroadcastAndKeyShare, 'createFilter',
new=create_filter_mock
):
sfilter = SkaleFilter(
skale.dkg.contract.events.BroadcastAndKeyShare,
from_block=0,
argument_filters={}
)
assert sfilter.get_events() == events
def test_skale_filter_with_exception(skale):
events = [{'event_id': 1}, {'event_id': 2}]
def create_filter_mock(*, fromBlock=0, toBlock=0, argument_filters={}):
cf_mock = mock.Mock()
cf_mock.get_all_entries = mock.Mock(
side_effect=ValueError('filter not found'),
return_value=events
)
return cf_mock
with mock.patch.object(
skale.dkg.contract.events.BroadcastAndKeyShare, 'createFilter',
new=create_filter_mock
):
sfilter = SkaleFilter(
skale.dkg.contract.events.BroadcastAndKeyShare,
from_block=0,
argument_filters={},
retries=2
)
with pytest.raises(SkaleFilterError):
sfilter.get_events()
def get_dkg_broadcast_filter(skale, group_index, from_block=0):
return SkaleFilter(skale.dkg.contract.events.BroadcastAndKeyShare,
from_block=from_block,
argument_filters={'groupIndex': group_index})
def get_dkg_bad_guy_filter(skale, from_block=0):
return SkaleFilter(skale.dkg.contract.events.BadGuy,
from_block=from_block,
argument_filters={})
def get_dkg_all_data_received_filter(skale, group_index, from_block=0):
return SkaleFilter(skale.dkg.contract.events.AllDataReceived,
from_block=from_block,
argument_filters={'groupIndex': group_index})
def get_dkg_fail_filter(skale, group_index, from_block=0):
return SkaleFilter(skale.dkg.contract.events.FailedDKG,
from_block=from_block,
argument_filters={'groupIndex': group_index})
def get_dkg_successful_filter(skale, group_index, from_block=0):
return SkaleFilter(skale.dkg.contract.events.SuccessfulDKG,
from_block=from_block,
argument_filters={'groupIndex': group_index})