def get_contract_events(
chain,
abi,
contract_address,
topics,
from_block,
to_block):
""" Query the blockchain for all events of the smart contract at
`contract_address` that match the filters `topics`, `from_block`, and
`to_block`.
"""
# Note: Issue #452 (https://github.com/raiden-network/raiden/issues/452)
# tracks a suggested TODO, which will reduce the 3 RPC calls here to only
# one using `eth_getLogs`. It will require changes in all testing frameworks
# to be implemented though.
events = get_filter_events(
chain.client,
contract_address,
topics=topics,
from_block=from_block,
to_block=to_block
)
result = []
for event in events:
decoded_event = dict(decode_event(abi, event['event_data']))
if event.get('block_number'):
decoded_event['block_number'] = event['block_number']
result.append(decoded_event)
return result
def poll_blockchain_events(self):
for event_listener in self.event_listeners:
for log_event in event_listener.filter.get_new_entries():
decoded_event = dict(
decode_event(
event_listener.abi,
log_event,
))
if decoded_event is not None:
decoded_event['block_number'] = log_event.get(
'blockNumber', 0)
event = Event(
to_canonical_address(log_event['address']),
decoded_event,
)
yield decode_event_to_internal(event)
def poll_event_listener(eth_filter, abi):
result = list()
for log_event in eth_filter.changes():
decoded_event = dict(decode_event(
abi,
log_event['event_data']
))
if decoded_event is not None:
decoded_event['block_number'] = log_event.get('block_number')
event = Event(
log_event['address'],
decoded_event,
)
result.append(event)
return result
def get_contract_events(chain, abi, contract_address, topics, from_block,
to_block):
""" Query the blockchain for all events of the smart contract at
`contract_address` that match the filters `topics`, `from_block`, and
`to_block`.
"""
events = chain.client.get_filter_events(contract_address,
topics=topics,
from_block=from_block,
to_block=to_block)
result = []
for event in events:
decoded_event = dict(decode_event(abi, event))
if event.get('blockNumber'):
decoded_event['block_number'] = event['blockNumber']
result.append(decoded_event)
return result
def test_blockchain(
init_blockchain,
web3,
blockchain_rpc_ports,
private_keys,
poll_timeout):
# pylint: disable=too-many-locals
addresses = [
privatekey_to_address(priv)
for priv in private_keys
]
privatekey = private_keys[0]
address = privatekey_to_address(privatekey)
total_token = 100
host = '127.0.0.1'
jsonrpc_client = JSONRPCClient(
host,
blockchain_rpc_ports[0],
privatekey,
web3=web3,
)
humantoken_path = get_contract_path('HumanStandardToken.sol')
humantoken_contracts = compile_files_cwd([humantoken_path])
token_proxy = jsonrpc_client.deploy_solidity_contract(
'HumanStandardToken',
humantoken_contracts,
list(),
(total_token, 'raiden', 2, 'Rd'),
contract_path=humantoken_path,
timeout=poll_timeout,
)
token_proxy = Token(jsonrpc_client, to_canonical_address(token_proxy.contract.address))
registry_path = get_contract_path('Registry.sol')
registry_contracts = compile_files_cwd([registry_path])
registry_proxy = jsonrpc_client.deploy_solidity_contract(
'Registry',
registry_contracts,
list(),
tuple(),
contract_path=registry_path,
timeout=poll_timeout,
)
registry_proxy = Registry(
jsonrpc_client,
to_canonical_address(registry_proxy.contract.address),
)
log_list = jsonrpc_client.web3.eth.getLogs(
{
'fromBlock': 0,
'toBlock': 'latest',
'topics': [],
},
)
assert not log_list
assert token_proxy.balance_of(address) == total_token
manager_address = registry_proxy.add_token(
to_canonical_address(token_proxy.proxy.contract.address),
)
assert is_address(manager_address)
assert len(registry_proxy.token_addresses()) == 1
log_list = jsonrpc_client.web3.eth.getLogs(
{
'fromBlock': 0,
'toBlock': 'latest',
'topics': [],
},
)
assert len(log_list) == 1
channel_manager_address_encoded = registry_proxy.manager_address_by_token(
token_proxy.proxy.contract.address,
)
channel_manager_address = to_canonical_address(channel_manager_address_encoded)
log = log_list[0]
event = decode_event(CONTRACT_MANAGER.get_contract_abi(CONTRACT_REGISTRY), log)
event_args = event['args']
assert channel_manager_address == to_canonical_address(event_args['channel_manager_address'])
assert is_same_address(token_proxy.proxy.contract.address, event_args['token_address'])
channel_manager_proxy = jsonrpc_client.new_contract_proxy(
CONTRACT_MANAGER.get_contract_abi(CONTRACT_CHANNEL_MANAGER),
channel_manager_address,
)
channel_manager_proxy = ChannelManager(
jsonrpc_client,
to_canonical_address(channel_manager_proxy.contract.address),
)
channel_address = channel_manager_proxy.new_netting_channel(
addresses[1],
10,
)
assert is_address(channel_address)
log_list = jsonrpc_client.web3.eth.getLogs(
{
'fromBlock': 0,
'toBlock': 'latest',
'topics': [],
},
)
assert len(log_list) == 2
