def test_blockchain(
blockchain_type,
blockchain_backend, # required to start the geth backend
blockchain_rpc_ports,
private_keys,
poll_timeout):
# pylint: disable=too-many-locals
# this test is for interaction with a blockchain using json-rpc, so it
# doesnt make sense to execute it against mock or tester
if blockchain_type not in ('geth',):
return
addresses = [
privatekey_to_address(priv)
for priv in private_keys
]
privatekey = private_keys[0]
address = privatekey_to_address(privatekey)
total_token = 100
jsonrpc_client = JSONRPCClient(
port=blockchain_rpc_ports[0],
privkey=privatekey,
print_communication=False,
)
patch_send_transaction(jsonrpc_client)
patch_send_message(jsonrpc_client)
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,
dict(),
(total_token, 'raiden', 2, 'Rd'),
contract_path=humantoken_path,
gasprice=default_gasprice,
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,
dict(),
tuple(),
contract_path=registry_path,
gasprice=default_gasprice,
timeout=poll_timeout,
)
log_list = jsonrpc_client.call(
'eth_getLogs',
{
'fromBlock': '0x0',
'toBlock': 'latest',
'topics': [],
},
)
assert len(log_list) == 0
# pylint: disable=no-member
assert token_proxy.balanceOf(address) == total_token
transaction_hash = registry_proxy.addToken.transact(
token_proxy.address,
gasprice=denoms.wei,
)
jsonrpc_client.poll(transaction_hash.decode('hex'), timeout=poll_timeout)
assert len(registry_proxy.tokenAddresses.call()) == 1
log_list = jsonrpc_client.call(
'eth_getLogs',
{
'fromBlock': '0x0',
'toBlock': 'latest',
'topics': [],
},
)
assert len(log_list) == 1
channel_manager_address_encoded = registry_proxy.channelManagerByToken.call(
token_proxy.address,
)
channel_manager_address = channel_manager_address_encoded.decode('hex')
log = log_list[0]
log_topics = [
decode_topic(topic)
for topic in log['topics'] # pylint: disable=invalid-sequence-index
]
log_data = log['data']
event = registry_proxy.translator.decode_event(
log_topics,
log_data[2:].decode('hex'),
)
assert channel_manager_address == event['channel_manager_address'].decode('hex')
assert token_proxy.address == event['token_address'].decode('hex')
channel_manager_proxy = jsonrpc_client.new_contract_proxy(
CHANNEL_MANAGER_ABI,
channel_manager_address,
)
transaction_hash = channel_manager_proxy.newChannel.transact(
addresses[1],
10,
gasprice=denoms.wei,
)
jsonrpc_client.poll(transaction_hash.decode('hex'), timeout=poll_timeout)
log_list = jsonrpc_client.call(
'eth_getLogs',
{
'fromBlock': '0x0',
'toBlock': 'latest',
'topics': [],
},
)
assert len(log_list) == 2
def test_blockchain(blockchain_backend, private_keys, number_of_nodes,
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_asset = 100
jsonrpc_client = JSONRPCClient(
privkey=privatekey,
print_communication=False,
)
patch_send_transaction(jsonrpc_client)
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,
dict(),
(total_asset, 'raiden', 2, 'Rd'),
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,
dict(),
tuple(),
timeout=poll_timeout,
)
log_list = jsonrpc_client.call(
'eth_getLogs',
{
'fromBlock': '0x0',
'toBlock': 'latest',
'topics': [],
},
)
assert len(log_list) == 0
# pylint: disable=no-member
assert token_proxy.balanceOf(address) == total_asset
transaction_hash = registry_proxy.addAsset.transact(
token_proxy.address,
gasprice=denoms.wei,
)
jsonrpc_client.poll(transaction_hash.decode('hex'), timeout=poll_timeout)
assert len(registry_proxy.assetAddresses.call()) == 1
log_list = jsonrpc_client.call(
'eth_getLogs',
{
'fromBlock': '0x0',
'toBlock': 'latest',
'topics': [],
},
)
assert len(log_list) == 1
channel_manager_address_encoded = registry_proxy.channelManagerByAsset.call(
token_proxy.address)
channel_manager_address = channel_manager_address_encoded.decode('hex')
log = log_list[0]
log_topics = [
decode_topic(topic) for topic in log['topics'] # pylint: disable=invalid-sequence-index
]
log_data = log['data']
event = registry_proxy.translator.decode_event(
log_topics,
log_data[2:].decode('hex'),
)
assert channel_manager_address == event['channelManagerAddress'].decode(
'hex')
assert token_proxy.address == event['assetAddress'].decode('hex')
channel_manager_proxy = jsonrpc_client.new_contract_proxy(
registry_contracts['ChannelManagerContract']['abi'],
channel_manager_address,
)
transaction_hash = channel_manager_proxy.newChannel.transact(
addresses[1],
10,
gasprice=denoms.wei,
)
jsonrpc_client.poll(transaction_hash.decode('hex'), timeout=poll_timeout)
log_list = jsonrpc_client.call(
'eth_getLogs',
{
'fromBlock': '0x0',
'toBlock': 'latest',
'topics': [],
},
)
assert len(log_list) == 2
def deployed_network(request, private_keys, channels_per_node, deposit,
number_of_assets, settle_timeout, poll_timeout,
transport_class, geth_cluster):
gevent.sleep(2)
assert channels_per_node in (0, 1, 2, CHAIN), (
'deployed_network uses create_sequential_network that can only work '
'with 0, 1 or 2 channels'
)
privatekey = private_keys[0]
address = privtoaddr(privatekey)
blockchain_service_class = BlockChainService
jsonrpc_client = JSONRPCClient(
host='0.0.0.0',
privkey=privatekey,
print_communication=False,
)
patch_send_transaction(jsonrpc_client)
humantoken_path = get_contract_path('HumanStandardToken.sol')
registry_path = get_contract_path('Registry.sol')
humantoken_contracts = compile_file(humantoken_path, libraries=dict())
registry_contracts = compile_file(registry_path, libraries=dict())
registry_proxy = jsonrpc_client.deploy_solidity_contract(
address,
'Registry',
registry_contracts,
dict(),
tuple(),
timeout=poll_timeout,
)
registry_address = registry_proxy.address
# Using 3 * deposit because we assume that is the maximum number of
# channels that will be created.
# `total_per_node = channels_per_node * deposit`
total_per_node = 3 * deposit
total_asset = total_per_node * len(private_keys)
asset_addresses = []
for _ in range(number_of_assets):
token_proxy = jsonrpc_client.deploy_solidity_contract(
address,
'HumanStandardToken',
humantoken_contracts,
dict(),
(total_asset, 'raiden', 2, 'Rd'),
timeout=poll_timeout,
)
asset_address = token_proxy.address
assert len(asset_address)
asset_addresses.append(asset_address)
transaction_hash = registry_proxy.addAsset(asset_address) # pylint: disable=no-member
jsonrpc_client.poll(transaction_hash.decode('hex'), timeout=poll_timeout)
# only the creator of the token starts with a balance, transfer from
# the creator to the other nodes
for transfer_to in private_keys:
if transfer_to != jsonrpc_client.privkey:
transaction_hash = token_proxy.transfer( # pylint: disable=no-member
privtoaddr(transfer_to),
total_per_node,
startgas=GAS_LIMIT,
)
jsonrpc_client.poll(transaction_hash.decode('hex'))
for key in private_keys:
assert token_proxy.balanceOf(privtoaddr(key)) == total_per_node # pylint: disable=no-member
raiden_apps = create_sequential_network(
private_keys,
asset_addresses[0],
registry_address,
channels_per_node,
deposit,
settle_timeout,
poll_timeout,
transport_class,
blockchain_service_class,
)
_raiden_cleanup(request, raiden_apps)
return raiden_apps
def test_blockchain(
blockchain_type,
blockchain_backend, # required to start the geth backend
blockchain_rpc_ports,
private_keys,
poll_timeout):
# pylint: disable=too-many-locals
# this test is for interaction with a blockchain using json-rpc, so it
# doesnt make sense to execute it against mock or tester
if blockchain_type not in ('geth',):
return
addresses = [
privatekey_to_address(priv)
for priv in private_keys
]
privatekey = private_keys[0]
address = privatekey_to_address(privatekey)
total_asset = 100
jsonrpc_client = JSONRPCClient(
port=blockchain_rpc_ports[0],
privkey=privatekey,
print_communication=False,
)
patch_send_transaction(jsonrpc_client)
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,
dict(),
(total_asset, 'raiden', 2, 'Rd'),
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,
dict(),
tuple(),
timeout=poll_timeout,
)
log_list = jsonrpc_client.call(
'eth_getLogs',
{
'fromBlock': '0x0',
'toBlock': 'latest',
'topics': [],
},
)
assert len(log_list) == 0
# pylint: disable=no-member
assert token_proxy.balanceOf(address) == total_asset
transaction_hash = registry_proxy.addAsset.transact(
token_proxy.address,
gasprice=denoms.wei,
)
jsonrpc_client.poll(transaction_hash.decode('hex'), timeout=poll_timeout)
assert len(registry_proxy.assetAddresses.call()) == 1
log_list = jsonrpc_client.call(
'eth_getLogs',
{
'fromBlock': '0x0',
'toBlock': 'latest',
'topics': [],
},
)
assert len(log_list) == 1
channel_manager_address_encoded = registry_proxy.channelManagerByAsset.call(
token_proxy.address,
)
channel_manager_address = channel_manager_address_encoded.decode('hex')
log = log_list[0]
log_topics = [
decode_topic(topic)
for topic in log['topics'] # pylint: disable=invalid-sequence-index
]
log_data = log['data']
event = registry_proxy.translator.decode_event(
log_topics,
log_data[2:].decode('hex'),
)
assert channel_manager_address == event['channel_manager_address'].decode('hex')
assert token_proxy.address == event['asset_address'].decode('hex')
channel_manager_proxy = jsonrpc_client.new_contract_proxy(
registry_contracts['ChannelManagerContract']['abi'],
channel_manager_address,
)
transaction_hash = channel_manager_proxy.newChannel.transact(
addresses[1],
10,
gasprice=denoms.wei,
)
jsonrpc_client.poll(transaction_hash.decode('hex'), timeout=poll_timeout)
log_list = jsonrpc_client.call(
'eth_getLogs',
{
'fromBlock': '0x0',
'toBlock': 'latest',
'topics': [],
},
)
assert len(log_list) == 2
def deployed_network(request, private_keys, channels_per_node, deposit,
number_of_assets, settle_timeout, poll_timeout,
transport_class, geth_cluster):
gevent.sleep(2)
assert channels_per_node in (0, 1, 2, CHAIN), (
'deployed_network uses create_sequential_network that can only work '
'with 0, 1 or 2 channels')
privatekey = private_keys[0]
address = privtoaddr(privatekey)
blockchain_service_class = BlockChainService
jsonrpc_client = JSONRPCClient(
host='0.0.0.0',
privkey=privatekey,
print_communication=False,
)
patch_send_transaction(jsonrpc_client)
humantoken_path = get_contract_path('HumanStandardToken.sol')
registry_path = get_contract_path('Registry.sol')
humantoken_contracts = compile_file(humantoken_path, libraries=dict())
registry_contracts = compile_file(registry_path, libraries=dict())
registry_proxy = jsonrpc_client.deploy_solidity_contract(
address,
'Registry',
registry_contracts,
dict(),
tuple(),
timeout=poll_timeout,
)
registry_address = registry_proxy.address
# Using 3 * deposit because we assume that is the maximum number of
# channels that will be created.
# `total_per_node = channels_per_node * deposit`
total_per_node = 3 * deposit
total_asset = total_per_node * len(private_keys)
asset_addresses = []
for _ in range(number_of_assets):
token_proxy = jsonrpc_client.deploy_solidity_contract(
address,
'HumanStandardToken',
humantoken_contracts,
dict(),
(total_asset, 'raiden', 2, 'Rd'),
timeout=poll_timeout,
)
asset_address = token_proxy.address
assert len(asset_address)
asset_addresses.append(asset_address)
transaction_hash = registry_proxy.addAsset(asset_address) # pylint: disable=no-member
jsonrpc_client.poll(transaction_hash.decode('hex'),
timeout=poll_timeout)
# only the creator of the token starts with a balance, transfer from
# the creator to the other nodes
for transfer_to in private_keys:
if transfer_to != jsonrpc_client.privkey:
transaction_hash = token_proxy.transfer( # pylint: disable=no-member
privtoaddr(transfer_to),
total_per_node,
startgas=GAS_LIMIT,
)
jsonrpc_client.poll(transaction_hash.decode('hex'))
for key in private_keys:
assert token_proxy.balanceOf(privtoaddr(key)) == total_per_node # pylint: disable=no-member
raiden_apps = create_sequential_network(
private_keys,
asset_addresses[0],
registry_address,
channels_per_node,
deposit,
settle_timeout,
poll_timeout,
transport_class,
blockchain_service_class,
)
_raiden_cleanup(request, raiden_apps)
return raiden_apps
def test_blockchain(request):
# pylint: disable=too-many-locals
from hydrachain import app
app.slogging.configure(':ERROR')
quantity = 3
base_port = 29870
timeout = 3 # seconds
tmp_datadir = tempfile.mktemp()
private_keys = [
mk_privkey('raidentest:{}'.format(position))
for position in range(quantity)
]
addresses = [
privtoaddr(priv)
for priv in private_keys
]
hydrachain_apps = hydrachain_network(private_keys, base_port, tmp_datadir)
privatekey = private_keys[0]
address = privtoaddr(privatekey)
jsonrpc_client = JSONRPCClient(privkey=private_keys[0], print_communication=False)
humantoken_path = get_contract_path('HumanStandardToken.sol')
humantoken_contracts = compile_file(humantoken_path, libraries=dict())
token_abi = jsonrpc_client.deploy_solidity_contract(
address,
'HumanStandardToken',
humantoken_contracts,
dict(),
(9999, 'raiden', 2, 'Rd'),
timeout=timeout,
)
registry_path = get_contract_path('Registry.sol')
registry_contracts = compile_file(registry_path, libraries=dict())
registry_abi = jsonrpc_client.deploy_solidity_contract(
address,
'Registry',
registry_contracts,
dict(),
tuple(),
timeout=timeout,
)
log_list = jsonrpc_client.call(
'eth_getLogs',
{
'fromBlock': '0x0',
'toBlock': 'latest',
'topics': [],
},
)
assert len(log_list) == 0
# pylint: disable=no-member
assert token_abi.balanceOf(address) == 9999
transaction_hash = registry_abi.addAsset(token_abi.address)
jsonrpc_client.poll(transaction_hash.decode('hex'), timeout=timeout)
log_list = jsonrpc_client.call(
'eth_getLogs',
{
'fromBlock': '0x0',
'toBlock': 'latest',
'topics': [],
},
)
assert len(log_list) == 1
channel_manager_address_encoded = registry_abi.channelManagerByAsset.call(token_abi.address)
channel_manager_address = channel_manager_address_encoded.decode('hex')
log_channel_manager_address_encoded = log_list[0]['data']
log_channel_manager_address = log_channel_manager_address_encoded[2:].lstrip('0').rjust(40, '0').decode('hex')
assert channel_manager_address == log_channel_manager_address
channel_manager_abi = jsonrpc_client.new_contract_proxy(
registry_contracts['ChannelManagerContract']['abi'],
channel_manager_address,
)
transaction_hash = channel_manager_abi.newChannel(addresses[1], 10)
jsonrpc_client.poll(transaction_hash.decode('hex'), timeout=timeout)
log_list = jsonrpc_client.call(
'eth_getLogs',
{
'fromBlock': '0x0',
'toBlock': 'latest',
'topics': [],
},
)
assert len(log_list) == 2
channel_manager_abi.get.call(
address.encode('hex'),
addresses[1].encode('hex'),
)
def test_blockchain(request):
# pylint: disable=too-many-locals
from hydrachain import app
app.slogging.configure(':ERROR')
quantity = 3
base_port = 29870
timeout = 3 # seconds
tmp_datadir = tempfile.mktemp()
private_keys = [
mk_privkey('raidentest:{}'.format(position))
for position in range(quantity)
]
addresses = [privtoaddr(priv) for priv in private_keys]
hydrachain_apps = hydrachain_network(private_keys, base_port, tmp_datadir)
privatekey = private_keys[0]
address = privtoaddr(privatekey)
jsonrpc_client = JSONRPCClient(privkey=private_keys[0],
print_communication=False)
humantoken_path = get_contract_path('HumanStandardToken.sol')
humantoken_contracts = compile_file(humantoken_path, libraries=dict())
token_abi = jsonrpc_client.deploy_solidity_contract(
address,
'HumanStandardToken',
humantoken_contracts,
dict(),
(9999, 'raiden', 2, 'Rd'),
timeout=timeout,
)
registry_path = get_contract_path('Registry.sol')
registry_contracts = compile_file(registry_path, libraries=dict())
registry_abi = jsonrpc_client.deploy_solidity_contract(
address,
'Registry',
registry_contracts,
dict(),
tuple(),
timeout=timeout,
)
log_list = jsonrpc_client.call(
'eth_getLogs',
{
'fromBlock': '0x0',
'toBlock': 'latest',
'topics': [],
},
)
assert len(log_list) == 0
# pylint: disable=no-member
assert token_abi.balanceOf(address) == 9999
transaction_hash = registry_abi.addAsset(token_abi.address)
jsonrpc_client.poll(transaction_hash.decode('hex'), timeout=timeout)
log_list = jsonrpc_client.call(
'eth_getLogs',
{
'fromBlock': '0x0',
'toBlock': 'latest',
'topics': [],
},
)
assert len(log_list) == 1
channel_manager_address_encoded = registry_abi.channelManagerByAsset.call(
token_abi.address)
channel_manager_address = channel_manager_address_encoded.decode('hex')
log_channel_manager_address_encoded = log_list[0]['data']
log_channel_manager_address = log_channel_manager_address_encoded[
2:].lstrip('0').rjust(40, '0').decode('hex')
assert channel_manager_address == log_channel_manager_address
channel_manager_abi = jsonrpc_client.new_contract_proxy(
registry_contracts['ChannelManagerContract']['abi'],
channel_manager_address,
)
transaction_hash = channel_manager_abi.newChannel(addresses[1], 10)
jsonrpc_client.poll(transaction_hash.decode('hex'), timeout=timeout)
log_list = jsonrpc_client.call(
'eth_getLogs',
{
'fromBlock': '0x0',
'toBlock': 'latest',
'topics': [],
},
)
assert len(log_list) == 2
channel_manager_abi.get.call(
address.encode('hex'),
addresses[1].encode('hex'),
)
