def main():
tmpdir = tempfile.mkdtemp()
geth_nodes = []
for i in range(NUM_GETH_NODES):
is_miner = i == 0
node_key = sha3(f'node:{i}'.encode())
p2p_port = START_PORT + i
rpc_port = START_RPCPORT + i
description = GethNodeDescription(
node_key,
rpc_port,
p2p_port,
is_miner,
)
geth_nodes.append(description)
rpc_endpoint = f'http://127.0.0.1:{START_RPCPORT}'
web3 = Web3(HTTPProvider(rpc_endpoint))
verbosity = 0
random_marker = remove_0x_prefix(hex(random.getrandbits(100)))
geth_processes = geth_run_private_blockchain( # NOQA
web3,
DEFAULT_ACCOUNTS,
geth_nodes,
tmpdir,
RAIDENTEST_CHAINID,
verbosity,
random_marker,
)
from IPython import embed
embed()
def web3(
blockchain_p2p_ports,
blockchain_private_keys,
blockchain_rpc_ports,
blockchain_type,
deploy_key,
private_keys,
random_marker,
request,
tmpdir,
chain_id,
):
""" Starts a private chain with accounts funded. """
# include the deploy key in the list of funded accounts
keys_to_fund = set(private_keys)
keys_to_fund.add(deploy_key)
keys_to_fund = sorted(keys_to_fund)
if blockchain_type == 'geth':
host = '0.0.0.0'
rpc_port = blockchain_rpc_ports[0]
endpoint = f'http://{host}:{rpc_port}'
web3 = Web3(HTTPProvider(endpoint))
assert len(blockchain_private_keys) == len(blockchain_rpc_ports)
assert len(blockchain_private_keys) == len(blockchain_p2p_ports)
geth_nodes = [
GethNodeDescription(
key,
rpc,
p2p,
miner=(pos == 0),
)
for pos, (key, rpc, p2p) in enumerate(zip(
blockchain_private_keys,
blockchain_rpc_ports,
blockchain_p2p_ports,
))
]
accounts_to_fund = [
privatekey_to_address(key)
for key in keys_to_fund
]
if _GETH_DATADIR:
base_datadir = _GETH_DATADIR
os.makedirs(base_datadir, exist_ok=True)
else:
base_datadir = str(tmpdir)
geth_processes = geth_run_private_blockchain(
web3=web3,
accounts_to_fund=accounts_to_fund,
geth_nodes=geth_nodes,
base_datadir=base_datadir,
chain_id=chain_id,
verbosity=request.config.option.verbose,
random_marker=random_marker,
)
yield web3
for process in geth_processes:
process.terminate()
cleanup_tasks()
else:
raise ValueError(f'unknown blockchain_type {blockchain_type}')
def web3(
blockchain_p2p_ports,
blockchain_private_keys,
blockchain_rpc_ports,
blockchain_type,
deploy_key,
private_keys,
random_marker,
request,
tmpdir,
ethereum_tester,
chain_id,
):
""" Starts a private chain with accounts funded. """
# include the deploy key in the list of funded accounts
keys_to_fund = set(private_keys)
keys_to_fund.add(deploy_key)
keys_to_fund = sorted(keys_to_fund)
if blockchain_type == 'geth':
host = '0.0.0.0'
rpc_port = blockchain_rpc_ports[0]
endpoint = f'http://{host}:{rpc_port}'
web3 = Web3(HTTPProvider(endpoint))
assert len(blockchain_private_keys) == len(blockchain_rpc_ports)
assert len(blockchain_private_keys) == len(blockchain_p2p_ports)
geth_nodes = [
GethNodeDescription(
key,
rpc,
p2p,
miner=(pos == 0),
) for pos, (key, rpc, p2p) in enumerate(
zip(
blockchain_private_keys,
blockchain_rpc_ports,
blockchain_p2p_ports,
))
]
accounts_to_fund = [privatekey_to_address(key) for key in keys_to_fund]
geth_processes = geth_run_private_blockchain(
web3,
accounts_to_fund,
geth_nodes,
str(tmpdir),
chain_id,
request.config.option.verbose,
random_marker,
)
yield web3
for process in geth_processes:
process.terminate()
cleanup_tasks()
elif blockchain_type == 'tester':
web3 = Web3(EthereumTesterProvider(ethereum_tester))
snapshot = ethereum_tester.take_snapshot()
fund_accounts(web3, keys_to_fund, ethereum_tester)
miner = Miner(web3)
miner.start()
yield web3
miner.stop.set()
miner.join()
ethereum_tester.revert_to_snapshot(snapshot)
else:
raise ValueError(f'unknown blockchain_type {blockchain_type}')
def setup_testchain_and_raiden(transport, matrix_server, print_step):
print_step('Starting Ethereum node')
ensure_executable('geth')
free_port = get_free_port('127.0.0.1', 27854)
rpc_port = next(free_port)
p2p_port = next(free_port)
base_datadir = os.environ['RST_DATADIR']
description = GethNodeDescription(
private_key=TEST_PRIVKEY,
rpc_port=rpc_port,
p2p_port=p2p_port,
miner=True,
)
eth_rpc_endpoint = f'http://127.0.0.1:{rpc_port}'
web3 = Web3(HTTPProvider(endpoint_uri=eth_rpc_endpoint))
web3.middleware_stack.inject(geth_poa_middleware, layer=0)
config = geth_node_config(
description.private_key,
description.p2p_port,
description.rpc_port,
)
config.update({
'unlock': 0,
'mine': True,
'password': os.path.join(base_datadir, 'pw'),
})
nodes_configuration = [config]
geth_node_config_set_bootnodes(nodes_configuration)
keystore = os.path.join(geth_node_to_datadir(config, base_datadir),
'keystore')
logdir = os.path.join(base_datadir, 'logs')
processes_list = geth_run_nodes(
geth_nodes=[description],
nodes_configuration=nodes_configuration,
base_datadir=base_datadir,
genesis_file=os.path.join(get_project_root(),
'smoketest_genesis.json'),
chain_id=NETWORKNAME_TO_ID['smoketest'],
verbosity=0,
logdir=logdir,
)
try:
# the marker is hardcoded in the genesis file
random_marker = remove_0x_prefix(encode_hex(b'raiden'))
geth_wait_and_check(web3, [], random_marker)
for process in processes_list:
process.poll()
if process.returncode is not None:
raise ValueError(
f'geth process failed with exit code {process.returncode}')
except (ValueError, RuntimeError) as e:
# If geth_wait_and_check or the above loop throw an exception make sure
# we don't end up with a rogue geth process running in the background
for process in processes_list:
process.terminate()
raise e
print_step('Deploying Raiden contracts')
client = JSONRPCClient(web3, get_private_key(keystore))
# for smoketest use the precompiled contracts
contract_manager = ContractManager(contracts_precompiled_path())
contract_addresses = deploy_smoketest_contracts(
client=client,
chain_id=NETWORKNAME_TO_ID['smoketest'],
contract_manager=contract_manager,
)
token = deploy_token(
deploy_client=client,
contract_manager=contract_manager,
initial_amount=1000,
decimals=0,
token_name='TKN',
token_symbol='TKN',
)
registry = TokenNetworkRegistry(
jsonrpc_client=client,
registry_address=contract_addresses[CONTRACT_TOKEN_NETWORK_REGISTRY],
contract_manager=contract_manager,
)
registry.add_token(to_canonical_address(token.contract.address))
print_step('Setting up Raiden')
if matrix_server == 'auto':
matrix_server = 'http://localhost:8008'
endpoint_registry_contract_address = to_checksum_address(
contract_addresses[CONTRACT_ENDPOINT_REGISTRY], )
tokennetwork_registry_contract_address = to_checksum_address(
contract_addresses[CONTRACT_TOKEN_NETWORK_REGISTRY], )
secret_registry_contract_address = to_checksum_address(
contract_addresses[CONTRACT_SECRET_REGISTRY], )
return {
'args': {
'address': to_checksum_address(TEST_ACCOUNT_ADDRESS),
'datadir': keystore,
'endpoint_registry_contract_address':
endpoint_registry_contract_address,
'eth_rpc_endpoint': eth_rpc_endpoint,
'gas_price': 'fast',
'keystore_path': keystore,
'matrix_server': matrix_server,
'network_id': str(NETWORKNAME_TO_ID['smoketest']),
'password_file': click.File()(os.path.join(base_datadir, 'pw')),
'tokennetwork_registry_contract_address':
tokennetwork_registry_contract_address,
'secret_registry_contract_address':
secret_registry_contract_address,
'sync_check': False,
'transport': transport,
},
'contract_addresses': contract_addresses,
'ethereum': processes_list,
'token': token,
}