def test_endpointregistry(private_keys, blockchain_services, contract_manager):
chain = blockchain_services.blockchain_services[0]
my_address = privatekey_to_address(private_keys[0])
endpointregistry_address = deploy_contract_web3(
contract_name=CONTRACT_ENDPOINT_REGISTRY,
deploy_client=chain.client,
contract_manager=contract_manager,
num_confirmations=None,
)
discovery_proxy = chain.discovery(endpointregistry_address)
contract_discovery = ContractDiscovery(my_address, discovery_proxy)
unregistered_address = make_address()
# get should raise for unregistered addresses
with pytest.raises(UnknownAddress):
contract_discovery.get(my_address)
with pytest.raises(UnknownAddress):
contract_discovery.get(unregistered_address)
contract_discovery.register(my_address, '127.0.0.1', 44444)
assert contract_discovery.get(my_address) == ('127.0.0.1', 44444)
contract_discovery.register(my_address, '127.0.0.1', 88888)
assert contract_discovery.get(my_address) == ('127.0.0.1', 88888)
with pytest.raises(UnknownAddress):
contract_discovery.get(unregistered_address)
def test_endpointregistry(private_keys, blockchain_services):
chain = blockchain_services.blockchain_services[0]
my_address = privatekey_to_address(private_keys[0])
endpointregistry_address = chain.deploy_contract(
'EndpointRegistry',
get_contract_path('EndpointRegistry.sol'),
)
discovery_proxy = chain.discovery(endpointregistry_address)
contract_discovery = ContractDiscovery(my_address, discovery_proxy)
unregistered_address = make_address()
# get should raise for unregistered addresses
with pytest.raises(UnknownAddress):
contract_discovery.get(my_address)
with pytest.raises(UnknownAddress):
contract_discovery.get(unregistered_address)
assert contract_discovery.nodeid_by_host_port(('127.0.0.1', 44444)) is None
contract_discovery.register(my_address, '127.0.0.1', 44444)
assert contract_discovery.nodeid_by_host_port(('127.0.0.1', 44444)) == my_address
assert contract_discovery.get(my_address) == ('127.0.0.1', 44444)
contract_discovery.register(my_address, '127.0.0.1', 88888)
assert contract_discovery.nodeid_by_host_port(('127.0.0.1', 88888)) == my_address
assert contract_discovery.get(my_address) == ('127.0.0.1', 88888)
with pytest.raises(UnknownAddress):
contract_discovery.get(unregistered_address)
def test_endpointregistry(private_keys, blockchain_services):
chain = blockchain_services.blockchain_services[0]
my_address = privatekey_to_address(private_keys[0])
endpointregistry_address = chain.deploy_contract(
'EndpointRegistry',
get_contract_path('EndpointRegistry.sol'),
)
discovery_proxy = chain.discovery(endpointregistry_address)
contract_discovery = ContractDiscovery(my_address, discovery_proxy)
unregistered_address = make_address()
# get should raise for unregistered addresses
with pytest.raises(KeyError):
contract_discovery.get(my_address)
with pytest.raises(KeyError):
contract_discovery.get(unregistered_address)
assert contract_discovery.nodeid_by_host_port(('127.0.0.1', 44444)) is None
contract_discovery.register(my_address, '127.0.0.1', 44444)
assert contract_discovery.nodeid_by_host_port(('127.0.0.1', 44444)) == my_address
assert contract_discovery.get(my_address) == ('127.0.0.1', 44444)
contract_discovery.register(my_address, '127.0.0.1', 88888)
assert contract_discovery.nodeid_by_host_port(('127.0.0.1', 88888)) == my_address
assert contract_discovery.get(my_address) == ('127.0.0.1', 88888)
with pytest.raises(KeyError):
contract_discovery.get(unregistered_address)
def test_endpointregistry(private_keys, blockchain_services, contract_manager):
chain = blockchain_services.blockchain_services[0]
my_address = privatekey_to_address(private_keys[0])
endpointregistry_address = deploy_contract_web3(
contract_name=CONTRACT_ENDPOINT_REGISTRY,
deploy_client=chain.client,
contract_manager=contract_manager,
)
discovery_proxy = chain.discovery(endpointregistry_address)
contract_discovery = ContractDiscovery(my_address, discovery_proxy)
unregistered_address = make_address()
# get should raise for unregistered addresses
with pytest.raises(UnknownAddress):
contract_discovery.get(my_address)
with pytest.raises(UnknownAddress):
contract_discovery.get(unregistered_address)
contract_discovery.register(my_address, '127.0.0.1', 44444)
assert contract_discovery.get(my_address) == ('127.0.0.1', 44444)
contract_discovery.register(my_address, '127.0.0.1', 88888)
assert contract_discovery.get(my_address) == ('127.0.0.1', 88888)
with pytest.raises(UnknownAddress):
contract_discovery.get(unregistered_address)
def app(privatekey, eth_rpc_endpoint, registry_contract_address,
discovery_contract_address, listen_address, external_listen_address,
logging, logfile):
slogging.configure(logging, log_file=logfile)
if not external_listen_address:
# notify('if you are behind a NAT, you should set
# `external_listen_address` and configure port forwarding on your router')
external_listen_address = listen_address
# config_file = args.config_file
(listen_host, listen_port) = split_endpoint(listen_address)
config = App.default_config.copy()
config['host'] = listen_host
config['port'] = listen_port
config['privatekey_hex'] = privatekey
endpoint = eth_rpc_endpoint
use_ssl = False
if eth_rpc_endpoint.startswith("http://"):
endpoint = eth_rpc_endpoint[len("http://"):]
rpc_port = 80
elif eth_rpc_endpoint.startswith("https://"):
endpoint = eth_rpc_endpoint[len("https://"):]
use_ssl = True
rpc_port = 443
if ':' not in endpoint: # no port was given in url
rpc_host = endpoint
else:
rpc_host, rpc_port = split_endpoint(endpoint)
jsonrpc_client = JSONRPCClient(
privkey=privatekey,
host=rpc_host,
port=rpc_port,
print_communication=False,
use_ssl=use_ssl,
)
blockchain_service = BlockChainService(
privatekey.decode('hex'),
registry_contract_address.decode('hex'),
)
discovery = ContractDiscovery(
jsonrpc_client,
discovery_contract_address.decode('hex')) # FIXME: double encoding
app = App(config, blockchain_service, discovery)
discovery.register(app.raiden.address,
*split_endpoint(external_listen_address))
app.raiden.register_registry(blockchain_service.default_registry)
return app
def app(privatekey, eth_rpc_endpoint, registry_contract_address,
discovery_contract_address, listen_address, external_listen_address,
logging):
slogging.configure(logging)
if not external_listen_address:
# notify('if you are behind a NAT, you should set
# `external_listen_address` and configure port forwarding on your router')
external_listen_address = listen_address
# config_file = args.config_file
rpc_connection = split_endpoint(eth_rpc_endpoint)
(listen_host, listen_port) = split_endpoint(listen_address)
config = App.default_config.copy()
config['host'] = listen_host
config['port'] = listen_port
config['privatekey_hex'] = privatekey
jsonrpc_client = JSONRPCClient(
privkey=privatekey,
host=rpc_connection[0],
port=rpc_connection[1],
print_communication=False,
)
blockchain_service = BlockChainService(
jsonrpc_client,
registry_contract_address.decode('hex'),
)
discovery = ContractDiscovery(
jsonrpc_client,
discovery_contract_address.decode('hex')) # FIXME: double encoding
app = App(config, blockchain_service, discovery)
discovery.register(app.raiden.address,
*split_endpoint(external_listen_address))
app.raiden.register_registry(blockchain_service.default_registry)
# TODO:
# - Ask for confirmation to quit if there are any locked transfers that did
# not timeout.
console = Console(app)
console.start()
# wait for interrupt
event = gevent.event.Event()
gevent.signal(signal.SIGQUIT, event.set)
gevent.signal(signal.SIGTERM, event.set)
gevent.signal(signal.SIGINT, event.set)
event.wait()
app.stop()
def app(privatekey, eth_rpc_endpoint, registry_contract_address,
discovery_contract_address, listen_address, external_listen_address, logging):
slogging.configure(logging)
if not external_listen_address:
# notify('if you are behind a NAT, you should set
# `external_listen_address` and configure port forwarding on your router')
external_listen_address = listen_address
# config_file = args.config_file
rpc_connection = split_endpoint(eth_rpc_endpoint)
(listen_host, listen_port) = split_endpoint(listen_address)
config = App.default_config.copy()
config['host'] = listen_host
config['port'] = listen_port
config['privatekey_hex'] = privatekey
jsonrpc_client = JSONRPCClient(
privkey=privatekey,
host=rpc_connection[0],
port=rpc_connection[1],
print_communication=False,
)
blockchain_service = BlockChainService(
jsonrpc_client,
registry_contract_address.decode('hex'),
)
discovery = ContractDiscovery(jsonrpc_client, discovery_contract_address.decode('hex')) # FIXME: double encoding
app = App(config, blockchain_service, discovery)
discovery.register(app.raiden.address, *split_endpoint(external_listen_address))
app.raiden.register_registry(blockchain_service.default_registry)
# TODO:
# - Ask for confirmation to quit if there are any locked transfers that did
# not timeout.
console = Console(app)
console.start()
# wait for interrupt
event = gevent.event.Event()
gevent.signal(signal.SIGQUIT, event.set)
gevent.signal(signal.SIGTERM, event.set)
gevent.signal(signal.SIGINT, event.set)
event.wait()
app.stop()
def test_endpointregistry(blockchain_services, poll_timeout):
chain = blockchain_services[0]
my_address = chain.node_address
# deploy discovery contract
discovery_contract_path = get_contract_path('EndpointRegistry.sol')
discovery_contracts = _solidity.compile_file(discovery_contract_path,
libraries=dict())
endpoinregistry_proxy = chain.client.deploy_solidity_contract(
my_address,
'EndpointRegistry',
discovery_contracts,
dict(),
tuple(),
timeout=poll_timeout,
)
endpointregistry_address = endpoinregistry_proxy.address
contract_discovery = ContractDiscovery(
chain,
endpointregistry_address,
)
unregistered_address = make_address()
# get should raise for unregistered addresses
with pytest.raises(KeyError):
contract_discovery.get(my_address)
with pytest.raises(KeyError):
contract_discovery.get(unregistered_address)
assert contract_discovery.nodeid_by_host_port(('127.0.0.1', 44444)) is None
contract_discovery.register(my_address, '127.0.0.1', 44444)
assert contract_discovery.nodeid_by_host_port(
('127.0.0.1', 44444)) == my_address
assert contract_discovery.get(my_address) == ('127.0.0.1', 44444)
contract_discovery.register(my_address, '127.0.0.1', 88888)
assert contract_discovery.nodeid_by_host_port(
('127.0.0.1', 88888)) == my_address
assert contract_discovery.get(my_address) == ('127.0.0.1', 88888)
with pytest.raises(KeyError):
contract_discovery.get(unregistered_address)
def test_endpointregistry_gas(private_keys, blockchain_services):
chain = blockchain_services.blockchain_services[0]
endpointregistry_address = chain.deploy_contract(
'EndpointRegistry',
get_contract_path('EndpointRegistry.sol'),
)
for i in range(len(private_keys)):
chain = blockchain_services.blockchain_services[i]
discovery_proxy = chain.discovery(endpointregistry_address)
my_address = privatekey_to_address(private_keys[i])
contract_discovery = ContractDiscovery(my_address, discovery_proxy)
contract_discovery.register(my_address, '127.0.0.{}'.format(i + 1), 44444)
chain.next_block()
def test_endpointregistry_gas(private_keys, blockchain_services):
chain = blockchain_services.blockchain_services[0]
endpointregistry_address = chain.deploy_contract(
'EndpointRegistry',
get_contract_path('EndpointRegistry.sol'),
)
for i in range(len(private_keys)):
chain = blockchain_services.blockchain_services[i]
discovery_proxy = chain.discovery(endpointregistry_address)
my_address = privatekey_to_address(private_keys[i])
contract_discovery = ContractDiscovery(my_address, discovery_proxy)
contract_discovery.register(my_address, '127.0.0.{}'.format(i + 1),
44444)
chain.next_block()
def test_endpointregistry_gas(private_keys, blockchain_services):
chain = blockchain_services.blockchain_services[0]
endpointregistry_address = deploy_contract_web3(
CONTRACT_ENDPOINT_REGISTRY,
chain.client,
)
for i in range(len(private_keys)):
chain = blockchain_services.blockchain_services[i]
discovery_proxy = chain.discovery(endpointregistry_address)
my_address = privatekey_to_address(private_keys[i])
contract_discovery = ContractDiscovery(my_address, discovery_proxy)
contract_discovery.register(my_address, '127.0.0.{}'.format(i + 1),
44444)
chain.next_block()
def test_endpointregistry(private_keys, blockchain_services):
chain = blockchain_services.blockchain_services[0]
my_address = privatekey_to_address(private_keys[0])
endpointregistry_address = deploy_contract_web3(
CONTRACT_ENDPOINT_REGISTRY,
chain.client,
)
discovery_proxy = chain.discovery(endpointregistry_address)
contract_discovery = ContractDiscovery(my_address, discovery_proxy)
unregistered_address = make_address()
# get should raise for unregistered addresses
with pytest.raises(UnknownAddress):
contract_discovery.get(my_address)
with pytest.raises(UnknownAddress):
contract_discovery.get(unregistered_address)
assert contract_discovery.nodeid_by_host_port(('127.0.0.1', 44444)) is None
contract_discovery.register(my_address, '127.0.0.1', 44444)
assert contract_discovery.nodeid_by_host_port(
('127.0.0.1', 44444)) == my_address
assert contract_discovery.get(my_address) == ('127.0.0.1', 44444)
contract_discovery.register(my_address, '127.0.0.1', 88888)
assert contract_discovery.nodeid_by_host_port(
('127.0.0.1', 88888)) == my_address
assert contract_discovery.get(my_address) == ('127.0.0.1', 88888)
with pytest.raises(UnknownAddress):
contract_discovery.get(unregistered_address)
def test_endpointregistry(private_keys, blockchain_services):
chain = blockchain_services.blockchain_services[0]
my_address = privatekey_to_address(private_keys[0])
endpointregistry_address = deploy_contract_web3(
CONTRACT_ENDPOINT_REGISTRY,
chain.client,
num_confirmations=None,
)
discovery_proxy = chain.discovery(endpointregistry_address)
contract_discovery = ContractDiscovery(my_address, discovery_proxy)
unregistered_address = make_address()
# get should raise for unregistered addresses
with pytest.raises(UnknownAddress):
contract_discovery.get(my_address)
with pytest.raises(UnknownAddress):
contract_discovery.get(unregistered_address)
assert contract_discovery.nodeid_by_host_port(('127.0.0.1', 44444)) is None
contract_discovery.register(my_address, '127.0.0.1', 44444)
assert contract_discovery.nodeid_by_host_port(('127.0.0.1', 44444)) == my_address
assert contract_discovery.get(my_address) == ('127.0.0.1', 44444)
contract_discovery.register(my_address, '127.0.0.1', 88888)
assert contract_discovery.nodeid_by_host_port(('127.0.0.1', 88888)) == my_address
assert contract_discovery.get(my_address) == ('127.0.0.1', 88888)
with pytest.raises(UnknownAddress):
contract_discovery.get(unregistered_address)