def __init__(
self,
jsonrpc_client,
registry_address,
poll_timeout=DEFAULT_POLL_TIMEOUT,
):
# pylint: disable=too-many-arguments
if not isaddress(registry_address):
raise InvalidAddress(
'Expected binary address format for token network registry')
check_address_has_code(jsonrpc_client, registry_address,
CONTRACT_TOKEN_NETWORK_REGISTRY)
proxy = jsonrpc_client.new_contract_proxy(
CONTRACT_MANAGER.get_abi(CONTRACT_TOKEN_NETWORK_REGISTRY),
address_encoder(registry_address),
)
CONTRACT_MANAGER.check_contract_version(
proxy.functions.contract_version().call(),
CONTRACT_TOKEN_NETWORK_REGISTRY)
self.address = registry_address
self.proxy = proxy
self.client = jsonrpc_client
self.poll_timeout = poll_timeout
self.node_address = privatekey_to_address(self.client.privkey)
self.address_to_tokennetwork = dict()
self.token_to_tokennetwork = dict()
def __init__(
self,
jsonrpc_client,
manager_address,
poll_timeout=DEFAULT_POLL_TIMEOUT,
):
# pylint: disable=too-many-arguments
contract = jsonrpc_client.new_contract(
CONTRACT_MANAGER.get_contract_abi(CONTRACT_CHANNEL_MANAGER),
to_normalized_address(manager_address),
)
self.proxy = ContractProxy(jsonrpc_client, contract)
if not is_binary_address(manager_address):
raise ValueError('manager_address must be a valid address')
check_address_has_code(jsonrpc_client, manager_address,
'Channel Manager')
CONTRACT_MANAGER.check_contract_version(
self.version(),
CONTRACT_CHANNEL_MANAGER,
)
self.address = manager_address
self.client = jsonrpc_client
self.poll_timeout = poll_timeout
self.open_channel_transactions = dict()
def test_deploy_contract(raiden_network, deploy_client, tmpdir):
"""Test deploying contract with different version than the one we have set in Registry.sol.
This test makes sense only for geth backend, tester uses mocked Registry class.
"""
contract_path = get_contract_path('Registry.sol')
# Create temporary directory to put all files required to compile the changed contract to.
# Why? Solidity uses first 40 characters of the file path as a library symbol.
# It would be nice to just do a copy of 'Registry.sol', replace version and include statements
# and then by path substitution argument of solc set the path to something like
# raiden-contracts=/path/to/your/raiden/source/contracts. But then if the path is too long,
# Python solidity compiler will fail because of duplicate library symbol.
temp_dir = TempSolidityDir(os.path.dirname(contract_path), tmpdir)
replaced_registry_path = os.path.join(temp_dir.name, 'Registry.sol')
CONTRACT_MANAGER.get_contract_abi(CONTRACT_CHANNEL_MANAGER)
replace_contract_version(replaced_registry_path, '0.0.31415')
contracts = compile_files_cwd([replaced_registry_path])
contract_proxy = deploy_client.deploy_solidity_contract(
'Registry',
contracts,
dict(),
None,
contract_path=replaced_registry_path,
)
contract_address = contract_proxy.contract_address
app0 = raiden_network[0]
with pytest.raises(ContractVersionMismatch):
app0.raiden.chain.registry(contract_address)
def __init__(
self,
jsonrpc_client,
discovery_address,
poll_timeout=DEFAULT_POLL_TIMEOUT,
):
contract = jsonrpc_client.new_contract(
CONTRACT_MANAGER.get_contract_abi(CONTRACT_ENDPOINT_REGISTRY),
to_normalized_address(discovery_address),
)
self.proxy = ContractProxy(jsonrpc_client, contract)
if not is_binary_address(discovery_address):
raise ValueError('discovery_address must be a valid address')
check_address_has_code(jsonrpc_client, discovery_address, 'Discovery')
CONTRACT_MANAGER.check_contract_version(
self.version(),
CONTRACT_ENDPOINT_REGISTRY,
)
self.address = discovery_address
self.client = jsonrpc_client
self.poll_timeout = poll_timeout
self.not_found_address = NULL_ADDRESS
def __init__(
self,
jsonrpc_client,
manager_address,
poll_timeout=DEFAULT_POLL_TIMEOUT):
# pylint: disable=too-many-arguments
if not isaddress(manager_address):
raise ValueError('manager_address must be a valid address')
check_address_has_code(jsonrpc_client, manager_address, 'Channel Manager')
proxy = jsonrpc_client.new_contract_proxy(
CONTRACT_MANAGER.get_contract_abi(CONTRACT_CHANNEL_MANAGER),
address_encoder(manager_address),
)
CONTRACT_MANAGER.check_contract_version(
proxy.call('contract_version').decode(),
CONTRACT_CHANNEL_MANAGER
)
self.address = manager_address
self.proxy = proxy
self.client = jsonrpc_client
self.poll_timeout = poll_timeout
self.open_channel_transactions = dict()
def __init__(
self,
jsonrpc_client,
registry_address,
poll_timeout=DEFAULT_POLL_TIMEOUT,
):
# pylint: disable=too-many-arguments
contract = jsonrpc_client.new_contract(
CONTRACT_MANAGER.get_contract_abi(CONTRACT_REGISTRY),
address_encoder(registry_address),
)
self.proxy = ContractProxy(jsonrpc_client, contract)
if not is_binary_address(registry_address):
raise ValueError('registry_address must be a valid address')
check_address_has_code(jsonrpc_client, registry_address, 'Registry')
CONTRACT_MANAGER.check_contract_version(
self.proxy.contract.functions.contract_version().call(),
CONTRACT_REGISTRY
)
self.address = registry_address
self.client = jsonrpc_client
self.poll_timeout = poll_timeout
self.node_address = privatekey_to_address(self.client.privkey)
self.address_to_channelmanager = dict()
self.token_to_channelmanager = dict()
def __init__(
self,
jsonrpc_client,
manager_address,
poll_timeout=DEFAULT_POLL_TIMEOUT,
):
# pylint: disable=too-many-arguments
if not isaddress(manager_address):
raise InvalidAddress(
'Expected binary address format for token nework')
check_address_has_code(jsonrpc_client, manager_address,
'Channel Manager')
proxy = jsonrpc_client.new_contract_proxy(
CONTRACT_MANAGER.get_abi(CONTRACT_TOKEN_NETWORK),
address_encoder(manager_address),
)
CONTRACT_MANAGER.check_contract_version(
proxy.functions.contract_version().call(), CONTRACT_TOKEN_NETWORK)
self.address = manager_address
self.proxy = proxy
self.client = jsonrpc_client
self.node_address = privatekey_to_address(self.client.privkey)
self.poll_timeout = poll_timeout
# Prevents concurrent deposit, withdraw, close, or settle operations on the same channel
self.channel_operations_lock = dict()
self.open_channel_transactions = dict()
def __init__(
self,
jsonrpc_client,
channel_address,
poll_timeout=DEFAULT_POLL_TIMEOUT,
):
contract = jsonrpc_client.new_contract(
CONTRACT_MANAGER.get_contract_abi(CONTRACT_NETTING_CHANNEL),
to_normalized_address(channel_address),
)
self.proxy = ContractProxy(jsonrpc_client, contract)
self.address = channel_address
self.client = jsonrpc_client
self.poll_timeout = poll_timeout
# Prevents concurrent deposit, close, or settle operations on the same channel
self.channel_operations_lock = RLock()
self.client = jsonrpc_client
self.node_address = privatekey_to_address(self.client.privkey)
CONTRACT_MANAGER.check_contract_version(
self.proxy.contract.functions.contract_version().call(),
CONTRACT_NETTING_CHANNEL,
)
# check we are a participant of the given channel
self.detail()
self._check_exists()
def test_nettingchannel_settle_timeout_inrange(private_keys, tester_channelmanager, tester_state):
""" The netting channel constructor must enforce that settle timeout is in
the valid range.
Also asserts that the constants.py and the netting channel contract values
are synched.
"""
pkey0 = private_keys[0]
pkey1 = private_keys[1]
pkey2 = private_keys[2]
log_listener = None
with pytest.raises(TransactionFailed):
small_settle_timeout = NETTINGCHANNEL_SETTLE_TIMEOUT_MIN - 1
tester_channelmanager.newChannel(
privatekey_to_address(pkey1),
small_settle_timeout,
sender=pkey0,
)
with pytest.raises(TransactionFailed):
big_settle_timeout = NETTINGCHANNEL_SETTLE_TIMEOUT_MAX + 1
tester_channelmanager.newChannel(
privatekey_to_address(pkey1),
big_settle_timeout,
sender=pkey0,
)
minimum_settle_timeout = NETTINGCHANNEL_SETTLE_TIMEOUT_MIN
netting_channel_address0_hex = tester_channelmanager.newChannel(
privatekey_to_address(pkey1),
minimum_settle_timeout,
sender=pkey0,
)
max_settle_timeout = NETTINGCHANNEL_SETTLE_TIMEOUT_MAX
netting_channel_address1_hex = tester_channelmanager.newChannel(
privatekey_to_address(pkey2),
max_settle_timeout,
sender=pkey0,
)
netting_channel = tester.ABIContract(
tester_state,
CONTRACT_MANAGER.get_translator(CONTRACT_NETTING_CHANNEL),
netting_channel_address0_hex,
log_listener=log_listener,
default_key=INVALID_KEY,
)
# pylint: disable=no-member
assert netting_channel.settleTimeout(sender=pkey0) == minimum_settle_timeout
netting_channel2 = tester.ABIContract(
tester_state,
CONTRACT_MANAGER.get_translator(CONTRACT_NETTING_CHANNEL),
netting_channel_address1_hex,
log_listener=log_listener,
default_key=INVALID_KEY,
)
assert netting_channel2.settleTimeout(sender=pkey0) == max_settle_timeout
def __init__(self,
jsonrpc_client,
discovery_address,
startgas=GAS_LIMIT,
gasprice=GAS_PRICE,
poll_timeout=DEFAULT_POLL_TIMEOUT):
result = jsonrpc_client.call(
'eth_getCode',
address_encoder(discovery_address),
'latest',
)
if result == '0x':
raise AddressWithoutCode(
'Discovery address {} does not contain code'.format(
address_encoder(discovery_address), ))
proxy = jsonrpc_client.new_abi_contract(
CONTRACT_MANAGER.get_abi(CONTRACT_ENDPOINT_REGISTRY),
address_encoder(discovery_address),
)
self.address = discovery_address
self.proxy = proxy
self.client = jsonrpc_client
self.startgas = startgas
self.gasprice = gasprice
self.poll_timeout = poll_timeout
def __init__(
self,
jsonrpc_client,
discovery_address,
):
contract = jsonrpc_client.new_contract(
CONTRACT_MANAGER.get_contract_abi(CONTRACT_ENDPOINT_REGISTRY),
to_normalized_address(discovery_address),
)
proxy = ContractProxy(jsonrpc_client, contract)
if not is_binary_address(discovery_address):
raise ValueError('discovery_address must be a valid address')
check_address_has_code(jsonrpc_client, discovery_address, 'Discovery')
is_valid_version = compare_versions(
proxy.contract.functions.contract_version().call(),
EXPECTED_CONTRACTS_VERSION,
)
if not is_valid_version:
raise ContractVersionMismatch('Incompatible ABI for Discovery')
self.address = discovery_address
self.client = jsonrpc_client
self.not_found_address = NULL_ADDRESS
self.proxy = proxy
def __init__(
self,
jsonrpc_client,
discovery_address,
startgas,
gasprice,
poll_timeout=DEFAULT_POLL_TIMEOUT):
if not isaddress(discovery_address):
raise ValueError('discovery_address must be a valid address')
check_address_has_code(jsonrpc_client, discovery_address, 'Discovery')
proxy = jsonrpc_client.new_contract_proxy(
CONTRACT_MANAGER.get_abi(CONTRACT_ENDPOINT_REGISTRY),
address_encoder(discovery_address),
)
self.address = discovery_address
self.proxy = proxy
self.client = jsonrpc_client
self.startgas = startgas
self.gasprice = gasprice
self.poll_timeout = poll_timeout
self.not_found_address = '0x' + '0' * 40
def __init__(self,
jsonrpc_client,
registry_address,
startgas,
gasprice,
poll_timeout=DEFAULT_POLL_TIMEOUT):
# pylint: disable=too-many-arguments
if not isaddress(registry_address):
raise ValueError('registry_address must be a valid address')
check_address_has_code(jsonrpc_client, registry_address)
proxy = jsonrpc_client.new_contract_proxy(
CONTRACT_MANAGER.get_abi(CONTRACT_REGISTRY),
address_encoder(registry_address),
)
self.address = registry_address
self.proxy = proxy
self.client = jsonrpc_client
self.startgas = startgas
self.gasprice = gasprice
self.poll_timeout = poll_timeout
self.address_to_channelmanager = dict()
self.token_to_channelmanager = dict()
def __init__(self,
jsonrpc_client,
registry_address,
startgas=GAS_LIMIT,
gasprice=GAS_PRICE,
poll_timeout=DEFAULT_POLL_TIMEOUT):
# pylint: disable=too-many-arguments
result = jsonrpc_client.call(
'eth_getCode',
address_encoder(registry_address),
'latest',
)
if result == '0x':
raise ValueError(
'Registry address {} does not contain code'.format(
address_encoder(registry_address), ))
proxy = jsonrpc_client.new_abi_contract(
CONTRACT_MANAGER.get_abi(CONTRACT_REGISTRY),
address_encoder(registry_address),
)
self.address = registry_address
self.proxy = proxy
self.client = jsonrpc_client
self.startgas = startgas
self.gasprice = gasprice
self.poll_timeout = poll_timeout
def channelnew_filter(self,
from_block: Union[str, int] = 0,
to_block: Union[str, int] = 'latest') -> Filter:
""" Install a new filter for ChannelNew events.
Args:
start_block:Create filter starting from this block number (default: 0).
end_block: Create filter stopping at this block number (default: 'latest').
Return:
The filter instance.
"""
topics = [CONTRACT_MANAGER.get_event_id(EVENT_CHANNEL_NEW)]
channel_manager_address_bin = self.proxy.contract_address
filter_id_raw = new_filter(self.client,
channel_manager_address_bin,
topics,
from_block=from_block,
to_block=to_block)
return Filter(
self.client,
filter_id_raw,
)
def __init__(self,
jsonrpc_client,
manager_address,
startgas,
gasprice,
poll_timeout=DEFAULT_POLL_TIMEOUT):
# pylint: disable=too-many-arguments
if not isaddress(manager_address):
raise ValueError('manager_address must be a valid address')
check_address_has_code(jsonrpc_client, manager_address,
'Channel Manager')
proxy = jsonrpc_client.new_contract_proxy(
CONTRACT_MANAGER.get_abi(CONTRACT_CHANNEL_MANAGER),
address_encoder(manager_address),
)
self.address = manager_address
self.proxy = proxy
self.client = jsonrpc_client
self.startgas = startgas
self.gasprice = gasprice
self.poll_timeout = poll_timeout
def new_nettingcontract(our_key, partner_key, tester_state, log_listener,
channelmanager, settle_timeout):
if settle_timeout < NETTINGCHANNEL_SETTLE_TIMEOUT_MIN:
raise ValueError('settle_timeout must be larger-or-equal to {}'.format(
NETTINGCHANNEL_SETTLE_TIMEOUT_MIN
))
netting_channel_address0_hex = channelmanager.newChannel(
privatekey_to_address(partner_key),
settle_timeout,
sender=our_key,
)
tester_state.mine(number_of_blocks=1)
nettingchannel_translator = tester.ContractTranslator(
CONTRACT_MANAGER.get_abi(CONTRACT_NETTING_CHANNEL)
)
nettingchannel = tester.ABIContract(
tester_state,
nettingchannel_translator,
netting_channel_address0_hex,
log_listener=log_listener,
default_key=INVALID_KEY,
)
return nettingchannel
def __init__(self,
jsonrpc_client,
token_address,
startgas=GAS_LIMIT,
gasprice=GAS_PRICE,
poll_timeout=DEFAULT_POLL_TIMEOUT):
if not isaddress(token_address):
raise ValueError('token_address must be a valid address')
result = jsonrpc_client.call(
'eth_getCode',
address_encoder(token_address),
'latest',
)
if result == '0x':
raise AddressWithoutCode(
'Token address {} does not contain code'.format(
address_encoder(token_address), ))
proxy = jsonrpc_client.new_abi_contract(
CONTRACT_MANAGER.get_abi(CONTRACT_HUMAN_STANDARD_TOKEN),
address_encoder(token_address),
)
self.address = token_address
self.proxy = proxy
self.client = jsonrpc_client
self.startgas = startgas
self.gasprice = gasprice
self.poll_timeout = poll_timeout
def __init__(
self,
jsonrpc_client,
registry_address,
startgas,
gasprice,
poll_timeout=DEFAULT_POLL_TIMEOUT):
# pylint: disable=too-many-arguments
if not isaddress(registry_address):
raise ValueError('registry_address must be a valid address')
check_address_has_code(jsonrpc_client, registry_address, 'Registry')
proxy = jsonrpc_client.new_contract_proxy(
CONTRACT_MANAGER.get_abi(CONTRACT_REGISTRY),
address_encoder(registry_address),
)
self.address = registry_address
self.proxy = proxy
self.client = jsonrpc_client
self.startgas = startgas
self.gasprice = gasprice
self.poll_timeout = poll_timeout
self.address_to_channelmanager = dict()
self.token_to_channelmanager = dict()
def tokenadded_filter(self, **kwargs):
"""May also receive from_block, to_block but they are not used here"""
topics = [CONTRACT_MANAGER.get_event_id(EVENT_TOKEN_ADDED)]
filter_ = FilterTesterMock(self.tester_chain, self.address, topics,
next(FILTER_ID_GENERATOR))
self.tester_chain.head_state.log_listeners.append(filter_.event)
return filter_
def __init__(self,
jsonrpc_client,
discovery_address,
startgas,
gasprice,
poll_timeout=DEFAULT_POLL_TIMEOUT):
if not isaddress(discovery_address):
raise ValueError('discovery_address must be a valid address')
result = jsonrpc_client.call(
'eth_getCode',
address_encoder(discovery_address),
'latest',
)
if result == '0x':
raise AddressWithoutCode(
'Discovery address {} does not contain code'.format(
address_encoder(discovery_address), ))
proxy = jsonrpc_client.new_contract_proxy(
CONTRACT_MANAGER.get_abi(CONTRACT_ENDPOINT_REGISTRY),
address_encoder(discovery_address),
)
self.address = discovery_address
self.proxy = proxy
self.client = jsonrpc_client
self.startgas = startgas
self.gasprice = gasprice
self.poll_timeout = poll_timeout
def __init__(self,
jsonrpc_client,
channel_address,
startgas=GAS_LIMIT,
gasprice=GAS_PRICE,
poll_timeout=DEFAULT_POLL_TIMEOUT):
# pylint: disable=too-many-arguments
result = jsonrpc_client.call(
'eth_getCode',
address_encoder(channel_address),
'latest',
)
if result == '0x':
raise AddressWithoutCode(
'Netting channel address {} does not contain code'.format(
address_encoder(channel_address), ))
proxy = jsonrpc_client.new_abi_contract(
CONTRACT_MANAGER.get_abi(CONTRACT_NETTING_CHANNEL),
address_encoder(channel_address),
)
self.address = channel_address
self.proxy = proxy
self.client = jsonrpc_client
self.startgas = startgas
self.gasprice = gasprice
self.poll_timeout = poll_timeout
# check we are a participant of the given channel
self.node_address = privatekey_to_address(self.client.privkey)
self.detail(self.node_address)
def __init__(self,
jsonrpc_client,
manager_address,
startgas=GAS_LIMIT,
gasprice=GAS_PRICE,
poll_timeout=DEFAULT_POLL_TIMEOUT):
# pylint: disable=too-many-arguments
if not isaddress(manager_address):
raise ValueError('manager_address must be a valid address')
result = jsonrpc_client.call(
'eth_getCode',
address_encoder(manager_address),
'latest',
)
if result == '0x':
raise AddressWithoutCode(
'Channel manager address {} does not contain code'.format(
address_encoder(manager_address), ))
proxy = jsonrpc_client.new_abi_contract(
CONTRACT_MANAGER.get_abi(CONTRACT_CHANNEL_MANAGER),
address_encoder(manager_address),
)
self.address = manager_address
self.proxy = proxy
self.client = jsonrpc_client
self.startgas = startgas
self.gasprice = gasprice
self.poll_timeout = poll_timeout
def channelnew_filter(self,
from_block: Union[str, int] = 0,
to_block: Union[str, int] = 'latest'):
topics = [CONTRACT_MANAGER.get_event_id(EVENT_CHANNEL_NEW)]
filter_ = FilterTesterMock(self.tester_chain, self.address, topics,
next(FILTER_ID_GENERATOR))
self.tester_chain.head_state.log_listeners.append(filter_.event)
return filter_
def add_netting_channel_listener(self, netting_channel_proxy):
channel_address = netting_channel_proxy.address
netting_channel_events = netting_channel_proxy.all_events_filter()
self.add_event_listener(
'NettingChannel Event {}'.format(pex(channel_address)),
netting_channel_events,
CONTRACT_MANAGER.get_translator('netting_channel'),
)
def add_channel_manager_listener(self, channel_manager_proxy):
channelnew = channel_manager_proxy.channelnew_filter()
manager_address = channel_manager_proxy.address
self.add_event_listener(
'ChannelManager {}'.format(pex(manager_address)),
channelnew,
CONTRACT_MANAGER.get_translator('channel_manager'),
)
def add_registry_listener(self, registry_proxy):
tokenadded = registry_proxy.tokenadded_filter()
registry_address = registry_proxy.address
self.add_event_listener(
'Registry {}'.format(pex(registry_address)),
tokenadded,
CONTRACT_MANAGER.get_translator(CONTRACT_REGISTRY),
)
def create_registryproxy(tester_chain, tester_registry_address, log_listener):
translator = tester.ContractTranslator(CONTRACT_MANAGER.get_abi(CONTRACT_REGISTRY))
tester_chain.head_state.log_listeners.append(log_listener)
registry_abi = tester.ABIContract(
tester_chain,
translator,
tester_registry_address,
)
return registry_abi
def create_registryproxy(tester_chain, tester_registry_address, log_listener):
translator = tester.ContractTranslator(CONTRACT_MANAGER.get_abi(CONTRACT_REGISTRY))
tester_chain.head_state.log_listeners.append(log_listener)
registry_abi = tester.ABIContract(
tester_chain,
translator,
tester_registry_address,
)
return registry_abi
def secret_registered_filter(self, from_block=None, to_block=None) -> Filter:
topics = [CONTRACT_MANAGER.get_event_id(EVENT_CHANNEL_SECRET_REVEALED)]
return self.client.new_filter(
self.address,
topics=topics,
from_block=from_block,
to_block=to_block,
)
def add_registry_listener(self, registry_proxy):
tokenadded = registry_proxy.tokenadded_filter()
registry_address = registry_proxy.address
self.add_event_listener(
'Registry {}'.format(pex(registry_address)),
tokenadded,
CONTRACT_MANAGER.get_translator(CONTRACT_REGISTRY),
registry_proxy.tokenadded_filter,
)
def add_channel_manager_listener(self, channel_manager_proxy):
channelnew = channel_manager_proxy.channelnew_filter()
manager_address = channel_manager_proxy.address
self.add_event_listener(
'ChannelManager {}'.format(pex(manager_address)),
channelnew,
CONTRACT_MANAGER.get_translator('channel_manager'),
channel_manager_proxy.channelnew_filter,
)
def add_netting_channel_listener(self, netting_channel_proxy):
netting_channel_events = netting_channel_proxy.all_events_filter()
channel_address = netting_channel_proxy.address
self.add_event_listener(
'NettingChannel Event {}'.format(pex(channel_address)),
netting_channel_events,
CONTRACT_MANAGER.get_translator('netting_channel'),
netting_channel_proxy.all_events_filter,
)
def tokenadded_filter(self, from_block=None, to_block=None) -> Filter:
topics = [CONTRACT_MANAGER.get_event_id(EVENT_TOKEN_ADDED)]
registry_address_bin = self.proxy.contract_address
return self.client.new_filter(
registry_address_bin,
topics=topics,
from_block=from_block,
to_block=to_block,
)
def channelnew_filter(self):
topics = [CONTRACT_MANAGER.get_event_id(EVENT_CHANNEL_NEW)]
filter_ = FilterTesterMock(
self.tester_chain,
self.address,
topics,
next(FILTER_ID_GENERATOR)
)
self.tester_chain.head_state.log_listeners.append(filter_.event)
return filter_
def create_tokenproxy(tester_chain, tester_token_address, log_listener):
translator = tester.ContractTranslator(
CONTRACT_MANAGER.get_abi(CONTRACT_HUMAN_STANDARD_TOKEN))
tester_chain.head_state.log_listeners.append(log_listener)
token_abi = tester.ABIContract(
tester_chain,
translator,
tester_token_address,
)
return token_abi
def create_nettingchannel_proxy(tester_chain, tester_nettingchannel_address, log_listener):
translator = tester.ContractTranslator(
CONTRACT_MANAGER.get_abi(CONTRACT_NETTING_CHANNEL)
)
tester_chain.head_state.log_listeners.append(log_listener)
netting_channel_abi = tester.ABIContract(
tester_chain,
translator,
tester_nettingchannel_address,
)
return netting_channel_abi
def create_channelmanager_proxy(tester_chain, tester_channelmanager_address, log_listener):
translator = tester.ContractTranslator(
CONTRACT_MANAGER.get_abi(CONTRACT_CHANNEL_MANAGER)
)
channel_manager_abi = tester.ABIContract(
tester_chain,
translator,
tester_channelmanager_address,
)
tester_chain.head_state.log_listeners.append(log_listener)
return channel_manager_abi
def tokenadded_filter(self, **kwargs):
"""May also receive from_block, to_block but they are not used here"""
topics = [CONTRACT_MANAGER.get_event_id(EVENT_TOKEN_ADDED)]
filter_ = FilterTesterMock(
self.tester_chain,
self.address,
topics,
next(FILTER_ID_GENERATOR)
)
self.tester_chain.head_state.log_listeners.append(filter_.event)
return filter_
def create_tokenproxy(tester_chain, tester_token_address, log_listener):
translator = tester.ContractTranslator(
CONTRACT_MANAGER.get_abi(CONTRACT_HUMAN_STANDARD_TOKEN)
)
tester_chain.head_state.log_listeners.append(log_listener)
token_abi = tester.ABIContract(
tester_chain,
translator,
tester_token_address,
)
return token_abi
def __init__(self, tester_chain, private_key, address):
if len(tester_chain.head_state.get_code(address)) == 0:
raise Exception('Contract code empty')
self.address = address
self.tester_chain = tester_chain
self.private_key = private_key
self.proxy = tester.ABIContract(
tester_chain,
CONTRACT_MANAGER.get_abi(CONTRACT_HUMAN_STANDARD_TOKEN),
address
)
def __init__(self, tester_chain, private_key, address):
if len(tester_chain.head_state.get_code(address)) == 0:
raise Exception('Contract code empty')
self.address = address
self.tester_chain = tester_chain
self.private_key = private_key
self.proxy = tester.ABIContract(
tester_chain,
CONTRACT_MANAGER.get_abi(CONTRACT_CHANNEL_MANAGER),
address
)
self.participant_filter = defaultdict(list)
self.address_filter = defaultdict(list)
def tokenadded_filter(self, from_block=None, to_block=None):
topics = [CONTRACT_MANAGER.get_event_id(EVENT_TOKEN_ADDED)]
registry_address_bin = self.proxy.contract_address
filter_id_raw = new_filter(
self.client,
registry_address_bin,
topics,
from_block=from_block,
to_block=to_block,
)
return Filter(
self.client,
filter_id_raw,
)
def netting_channel_events(
rpc: JSONRPCClient,
netting_channel: NettingChannel,
end_block: Union[str, int] = 'latest') -> List[Dict]:
"""Get all events for a netting_channel starting from its `opened()` block.
Args:
rpc: client instance.
netting_channel: the NettingChannel instance.
end_block: read event-logs up to this block number (default: 'latest').
"""
return all_contract_events(
rpc,
netting_channel.address,
CONTRACT_MANAGER.get_translator(CONTRACT_NETTING_CHANNEL),
start_block=netting_channel.opened(),
end_block=end_block
)
def __init__(self, tester_chain, private_key, address):
if len(tester_chain.head_state.get_code(address)) == 0:
raise Exception('Contract code empty')
self.address = address
self.tester_chain = tester_chain
self.private_key = private_key
self.registry_proxy = tester.ABIContract(
self.tester_chain,
CONTRACT_MANAGER.get_abi(CONTRACT_REGISTRY),
self.address
)
self.tokenadded_filters = list()
self.address_to_channelmanager = dict()
self.token_to_channelmanager = dict()
def get_all_registry_events(
chain,
registry_address,
events=ALL_EVENTS,
from_block=0,
to_block='latest'):
""" Helper to get all events of the Registry contract at
`registry_address`.
"""
return get_contract_events(
chain,
CONTRACT_MANAGER.get_translator(CONTRACT_REGISTRY),
registry_address,
events,
from_block,
to_block,
)
def get_all_netting_channel_events(
chain,
netting_channel_address,
events=ALL_EVENTS,
from_block=0,
to_block='latest'):
""" Helper to get all events of a NettingChannelContract at
`netting_channel_address`.
"""
return get_contract_events(
chain,
CONTRACT_MANAGER.get_translator(CONTRACT_NETTING_CHANNEL),
netting_channel_address,
events,
from_block,
to_block,
)
def get_all_channel_manager_events(
chain,
channel_manager_address,
events=ALL_EVENTS,
from_block=0,
to_block='latest'):
""" Helper to get all events of the ChannelManagerContract at
`token_address`.
"""
return get_contract_events(
chain,
CONTRACT_MANAGER.get_translator(CONTRACT_CHANNEL_MANAGER),
channel_manager_address,
events,
from_block,
to_block,
)
def __init__(self, tester_chain, private_key, address):
if len(tester_chain.head_state.get_code(address)) == 0:
raise Exception('Contract code empty')
self.address = address
self.tester_chain = tester_chain
self.private_key = private_key
self.proxy = tester.ABIContract(
tester_chain,
CONTRACT_MANAGER.get_abi(CONTRACT_NETTING_CHANNEL),
address
)
self.newbalance_filters = list()
self.secretrevealed_filters = list()
self.channelclose_filters = list()
self.channelsettle_filters = list()
# check we are a participant of the channel
self.detail()
def __init__(
self,
jsonrpc_client,
token_address,
startgas,
gasprice,
poll_timeout=DEFAULT_POLL_TIMEOUT):
if not isaddress(token_address):
raise ValueError('token_address must be a valid address')
check_address_has_code(jsonrpc_client, token_address, 'Token')
proxy = jsonrpc_client.new_contract_proxy(
CONTRACT_MANAGER.get_abi(CONTRACT_HUMAN_STANDARD_TOKEN),
address_encoder(token_address),
)
self.address = token_address
self.proxy = proxy
self.client = jsonrpc_client
self.startgas = startgas
self.gasprice = gasprice
self.poll_timeout = poll_timeout
def registry_abi():
return CONTRACT_MANAGER.get_abi(CONTRACT_REGISTRY)
def netting_channel_abi():
return CONTRACT_MANAGER.get_abi(CONTRACT_NETTING_CHANNEL)
def test_blockchain(
blockchain_backend, # required to start the geth backend pylint: disable=unused-argument
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,
)
humantoken_path = get_contract_path('HumanStandardToken.sol')
humantoken_contracts = compile_file(humantoken_path, libraries=dict())
token_proxy = jsonrpc_client.deploy_solidity_contract(
address,
'HumanStandardToken',
humantoken_contracts,
list(),
(total_token, 'raiden', 2, 'Rd'),
contract_path=humantoken_path,
gasprice=GAS_PRICE,
timeout=poll_timeout,
)
registry_path = get_contract_path('Registry.sol')
registry_contracts = compile_file(registry_path)
registry_proxy = jsonrpc_client.deploy_solidity_contract(
address,
'Registry',
registry_contracts,
list(),
tuple(),
contract_path=registry_path,
gasprice=GAS_PRICE,
timeout=poll_timeout,
)
log_list = jsonrpc_client.call(
'eth_getLogs',
{
'fromBlock': '0x0',
'toBlock': 'latest',
'topics': [],
},
)
assert not log_list
assert token_proxy.call('balanceOf', address) == total_token
transaction_hash = registry_proxy.transact(
'addToken',
token_proxy.contract_address,
gasprice=denoms.wei,
)
jsonrpc_client.poll(unhexlify(transaction_hash), timeout=poll_timeout)
assert len(registry_proxy.call('tokenAddresses')) == 1
log_list = jsonrpc_client.call(
'eth_getLogs',
{
'fromBlock': '0x0',
'toBlock': 'latest',
'topics': [],
},
)
assert len(log_list) == 1
channel_manager_address_encoded = registry_proxy.call(
'channelManagerByToken',
token_proxy.contract_address,
)
channel_manager_address = normalize_address(channel_manager_address_encoded)
log = log_list[0]
log_topics = [
topic_decoder(topic)
for topic in log['topics'] # pylint: disable=invalid-sequence-index
]
log_data = log['data'] # pylint: disable=invalid-sequence-index
event = registry_proxy.translator.decode_event(
log_topics,
unhexlify(log_data[2:]),
)
assert channel_manager_address == normalize_address(event['channel_manager_address'])
assert token_proxy.contract_address == normalize_address(event['token_address'])
channel_manager_proxy = jsonrpc_client.new_contract_proxy(
CONTRACT_MANAGER.get_abi(CONTRACT_CHANNEL_MANAGER),
channel_manager_address,
)
transaction_hash = channel_manager_proxy.transact(
'newChannel',
addresses[1],
10,
gasprice=denoms.wei,
)
jsonrpc_client.poll(unhexlify(transaction_hash), timeout=poll_timeout)
log_list = jsonrpc_client.call(
'eth_getLogs',
{
'fromBlock': '0x0',
'toBlock': 'latest',
'topics': [],
},
)
assert len(log_list) == 2
def token_abi():
return CONTRACT_MANAGER.get_abi(CONTRACT_HUMAN_STANDARD_TOKEN)
def channel_manager_abi():
return CONTRACT_MANAGER.get_abi(CONTRACT_CHANNEL_MANAGER)
def run(self):
os.environ['STORE_PRECOMPILED'] = 'yes'
from raiden.blockchain.abi import CONTRACT_MANAGER
CONTRACT_MANAGER.instantiate()
def test_query_events(raiden_chain, deposit, settle_timeout, events_poll_timeout):
app0, app1 = raiden_chain # pylint: disable=unbalanced-tuple-unpacking
token_address = app0.raiden.default_registry.token_addresses()[0]
assert len(app0.raiden.token_to_channelgraph[token_address].address_to_channel) == 0
assert len(app1.raiden.token_to_channelgraph[token_address].address_to_channel) == 0
token0 = app0.raiden.chain.token(token_address)
manager0 = app0.raiden.default_registry.manager_by_token(token_address)
events = get_all_registry_events(
app0.raiden.chain,
app0.raiden.default_registry.address,
events=ALL_EVENTS,
from_block=0,
to_block='latest',
)
assert len(events) == 1
assert event_dicts_are_equal(events[0], {
'_event_type': b'TokenAdded',
'channel_manager_address': address_encoder(manager0.address),
'token_address': address_encoder(token_address),
'block_number': 'ignore',
})
events = get_all_registry_events(
app0.raiden.chain,
app0.raiden.default_registry.address,
events=ALL_EVENTS,
from_block=999999998,
to_block=999999999,
)
assert not events
netcontract_address = manager0.new_netting_channel(
app1.raiden.address,
settle_timeout,
)
events = get_all_channel_manager_events(
app0.raiden.chain,
manager0.address,
events=ALL_EVENTS,
from_block=0,
to_block='latest',
)
assert len(events) == 1
assert event_dicts_are_equal(events[0], {
'_event_type': b'ChannelNew',
'settle_timeout': settle_timeout,
'netting_channel': address_encoder(netcontract_address),
'participant1': address_encoder(app0.raiden.address),
'participant2': address_encoder(app1.raiden.address),
'block_number': 'ignore',
})
events = get_all_channel_manager_events(
app0.raiden.chain,
manager0.address,
events=ALL_EVENTS,
from_block=999999998,
to_block=999999999,
)
assert not events
netting_channel0 = app0.raiden.chain.netting_channel(netcontract_address)
gevent.sleep(events_poll_timeout * 2)
# channel is created but not opened and without funds
assert len(app0.raiden.token_to_channelgraph[token_address].address_to_channel) == 1
assert len(app1.raiden.token_to_channelgraph[token_address].address_to_channel) == 1
channel0 = list(app0.raiden.token_to_channelgraph[token_address].address_to_channel.values())[0] # noqa: E501
channel1 = list(app1.raiden.token_to_channelgraph[token_address].address_to_channel.values())[0] # noqa: E501
assert_synched_channels(
channel0, 0, [],
channel1, 0, [],
)
token0.approve(netcontract_address, deposit)
netting_channel0.deposit(deposit)
all_netting_channel_events = get_all_netting_channel_events(
app0.raiden.chain,
netting_channel_address=netcontract_address,
from_block=0,
to_block='latest',
)
events = get_all_netting_channel_events(
app0.raiden.chain,
netcontract_address,
events=[CONTRACT_MANAGER.get_event_id(EVENT_CHANNEL_NEW_BALANCE)],
)
assert len(all_netting_channel_events) == 1
assert len(events) == 1
new_balance_event = {
'_event_type': b'ChannelNewBalance',
'token_address': address_encoder(token_address),
'participant': address_encoder(app0.raiden.address),
'balance': deposit,
'block_number': 'ignore',
}
assert event_dicts_are_equal(all_netting_channel_events[-1], new_balance_event)
assert event_dicts_are_equal(events[0], new_balance_event)
channel0.external_state.close(None)
all_netting_channel_events = get_all_netting_channel_events(
app0.raiden.chain,
netting_channel_address=netcontract_address,
from_block=0,
to_block='latest',
)
events = get_all_netting_channel_events(
app0.raiden.chain,
netcontract_address,
events=[CONTRACT_MANAGER.get_event_id(EVENT_CHANNEL_CLOSED)],
)
assert len(all_netting_channel_events) == 2
assert len(events) == 1
closed_event = {
'_event_type': b'ChannelClosed',
'closing_address': address_encoder(app0.raiden.address),
'block_number': 'ignore',
}
assert event_dicts_are_equal(all_netting_channel_events[-1], closed_event)
assert event_dicts_are_equal(events[0], closed_event)
settle_expiration = app0.raiden.chain.block_number() + settle_timeout + 1
wait_until_block(app0.raiden.chain, settle_expiration)
channel1.external_state.settle()
all_netting_channel_events = get_all_netting_channel_events(
app0.raiden.chain,
netting_channel_address=netcontract_address,
from_block=0,
to_block='latest',
)
events = get_all_netting_channel_events(
app0.raiden.chain,
netcontract_address,
events=[CONTRACT_MANAGER.get_event_id(EVENT_CHANNEL_SETTLED)],
)
assert len(all_netting_channel_events) == 3
assert len(events) == 1
settled_event = {
'_event_type': b'ChannelSettled',
'block_number': 'ignore',
}
assert event_dicts_are_equal(all_netting_channel_events[-1], settled_event)
assert event_dicts_are_equal(events[0], settled_event)
