def test_token_approve():
test_path = os.path.join(os.path.dirname(__file__),
'SimpleApproveTransfer.sol')
standard_token_path = get_contract_path('StandardToken.sol')
human_token_path = get_contract_path('HumanStandardToken.sol')
state = tester.state()
state.block.number = 1158001
address0 = tester.a0
address1 = tester.a1
standard_token = state.abi_contract(
None,
path=standard_token_path,
language='solidity',
)
contract_libraries = {
'StandardToken': standard_token.address.encode('hex'),
}
human_token = state.abi_contract(
None,
path=human_token_path,
language='solidity',
libraries=contract_libraries,
constructor_parameters=[10000, 'raiden', 0, 'rd'],
)
test = state.abi_contract(
None,
path=test_path,
language='solidity',
constructor_parameters=[human_token.address],
)
# pylint: disable=no-member
assert human_token.balanceOf(address0) == 10000
assert human_token.balanceOf(address1) == 0
assert human_token.balanceOf(test.address) == 0
assert human_token.allowance(address0, address0) == 0
assert human_token.allowance(address0, address1) == 0
assert human_token.allowance(address0, test.address) == 0
assert human_token.approve(test.address, 5000) is True
assert human_token.balanceOf(address0) == 10000
assert human_token.balanceOf(address1) == 0
assert human_token.balanceOf(test.address) == 0
assert human_token.allowance(address0, address0) == 0
assert human_token.allowance(address0, address1) == 0
assert human_token.allowance(address0, test.address) == 5000
assert test.transfer(address1, 2000) is True
assert human_token.balanceOf(address0) == 10000 - 2000
assert human_token.balanceOf(address1) == 0 + 2000
assert human_token.balanceOf(test.address) == 0
assert human_token.allowance(address0, address0) == 0
assert human_token.allowance(address0, address1) == 0
assert human_token.allowance(address0, test.address) == 5000 - 2000
def tester_token_address(private_keys, asset_amount, tester_state):
standard_token_path = get_contract_path('StandardToken.sol')
human_token_path = get_contract_path('HumanStandardToken.sol')
standard_token_address = tester_state.contract(
None,
path=standard_token_path,
language='solidity',
)
tester_state.mine(number_of_blocks=1)
human_token_libraries = {
'StandardToken': standard_token_address.encode('hex'),
}
# using abi_contract because of the constructor_parameters
human_token_proxy = tester_state.abi_contract(
None,
path=human_token_path,
language='solidity',
libraries=human_token_libraries,
constructor_parameters=[asset_amount, 'raiden', 0, 'rd'],
sender=private_keys[0],
)
tester_state.mine(number_of_blocks=1)
human_token_address = human_token_proxy.address
return human_token_address
def test_token():
standard_token_path = get_contract_path('StandardToken.sol')
human_token_path = get_contract_path('HumanStandardToken.sol')
state = tester.state()
state.block.number = 1158001
address0 = tester.a0
address1 = tester.a1
standard_token = state.abi_contract(
None,
path=standard_token_path,
language='solidity',
)
contract_libraries = {
'StandardToken': standard_token.address.encode('hex'),
}
human_token = state.abi_contract(
None,
path=human_token_path,
language='solidity',
libraries=contract_libraries,
constructor_parameters=[10000, 'raiden', 0, 'rd'],
)
# pylint: disable=no-member
assert human_token.balanceOf(address0) == 10000
assert human_token.balanceOf(address1) == 0
assert human_token.transfer(address1, 5000) is True
assert human_token.balanceOf(address0) == 5000
assert human_token.balanceOf(address1) == 5000
def test_token():
token_library_path = get_contract_path('StandardToken.sol')
token_path = get_contract_path('HumanStandardToken.sol')
state = tester.state()
assert state.block.number < 1150000
state.block.number = 1158001
assert state.block.number > 1150000
token = state.abi_contract(
None,
path=token_library_path,
language='solidity',
)
contract_libraries = {
'StandardToken': token.address.encode('hex'),
}
contract = state.abi_contract(
None,
path=token_path,
language='solidity',
libraries=contract_libraries,
constructor_parameters=[10000, 'raiden', 0, 'rd'],
)
# pylint: disable=no-member
assert contract.balanceOf(tester.a0) == 10000
assert contract.balanceOf(tester.a1) == 0
assert contract.transfer(tester.a1, 5000) is True
assert contract.balanceOf(tester.a0) == 5000
assert contract.balanceOf(tester.a1) == 5000
def test_ncc():
token_library_path = get_contract_path('StandardToken.sol')
token_path = get_contract_path('HumanStandardToken.sol')
state = tester.state()
assert state.block.number < 1150000
state.block.number = 1158001
assert state.block.number > 1150000
token = state.abi_contract(
None,
path=token_library_path,
language='solidity',
)
contract_libraries = {
'StandardToken': token.address.encode('hex'),
}
contract = state.abi_contract(
None,
path=token_path,
language='solidity',
libraries=contract_libraries,
constructor_parameters=[10000, 'raiden', 0, 'rd'],
)
# pylint: disable=no-member
assert contract.balanceOf(tester.a0) == 10000
assert contract.balanceOf(tester.a1) == 0
assert contract.transfer(tester.a1, 5000) is True
assert contract.balanceOf(tester.a0) == 5000
assert contract.balanceOf(tester.a1) == 5000
def discovery_blockchain(request, private_keys, geth_cluster, poll_timeout):
gevent.sleep(2)
privatekey = private_keys[0]
address = privtoaddr(privatekey)
jsonrpc_client = JSONRPCClient(
host='0.0.0.0',
privkey=privatekey,
print_communication=False,
)
patch_send_transaction(jsonrpc_client)
# deploy discovery contract
discovery_contract_path = get_contract_path('EndpointRegistry.sol')
discovery_contracts = compile_file(discovery_contract_path,
libraries=dict())
discovery_contract_proxy = jsonrpc_client.deploy_solidity_contract(
address,
'EndpointRegistry',
discovery_contracts,
dict(),
tuple(),
timeout=poll_timeout,
)
discovery_contract_address = discovery_contract_proxy.address
# initialize and return ContractDiscovery object
from raiden.network.discovery import ContractDiscovery
return ContractDiscovery(jsonrpc_client,
discovery_contract_address), address
def discovery_blockchain(request, private_keys, geth_cluster, poll_timeout):
gevent.sleep(2)
privatekey = private_keys[0]
address = privtoaddr(privatekey)
jsonrpc_client = JSONRPCClient(
host='0.0.0.0',
privkey=privatekey,
print_communication=False,
)
patch_send_transaction(jsonrpc_client)
# deploy discovery contract
discovery_contract_path = get_contract_path('EndpointRegistry.sol')
discovery_contracts = compile_file(discovery_contract_path, libraries=dict())
discovery_contract_proxy = jsonrpc_client.deploy_solidity_contract(
address,
'EndpointRegistry',
discovery_contracts,
dict(),
tuple(),
timeout=poll_timeout,
)
discovery_contract_address = discovery_contract_proxy.address
# initialize and return ContractDiscovery object
from raiden.network.discovery import ContractDiscovery
return ContractDiscovery(jsonrpc_client, discovery_contract_address), address
def create_and_distribute_token(client, receivers,
amount_per_receiver=1000,
name=None,
gasprice=denoms.shannon * 20,
timeout=120):
"""Create a new ERC-20 token and distribute it among `receivers`.
If `name` is None, the name will be derived from hashing all receivers.
"""
name = name or sha3(''.join(receivers)).encode('hex')
token_proxy = client.deploy_solidity_contract(
client.sender,
'HumanStandardToken',
compile_file(get_contract_path('HumanStandardToken.sol')),
dict()
(
len(receivers) * amount_per_receiver,
name,
2, # decimals
name[:4].upper() # symbol
),
gasprice=gasprice,
timeout=timeout
)
for receiver in receivers:
token_proxy.transfer(receiver, amount_per_receiver)
return token_proxy.address.encode('hex')
def test_endpointregistry():
registry_contract_path = get_contract_path('EndpointRegistry.sol')
events = []
state = tester.state()
assert state.block.number < 1150000
state.block.number = 1158001
assert state.block.number > 1150000
sender = tester.a0.encode('hex')
registry_contract = state.abi_contract(
None,
path=registry_contract_path,
language='solidity',
log_listener=events.append,
)
sender = tester.a0.encode('hex')
registry_contract.registerEndpoint('127.0.0.1:4001')
assert registry_contract.findAddressByEndpoint('127.0.0.1:4001') == sender
assert registry_contract.findEndpointByAddress(sender) == '127.0.0.1:4001'
registry_contract.updateEndpoint('192.168.0.1:4002')
assert registry_contract.findAddressByEndpoint(
'192.168.0.1:4002') == sender
assert registry_contract.findEndpointByAddress(
sender) == '192.168.0.1:4002'
assert len(events) == 2
assert events[0]['_event_type'] == 'AddressRegistered'
assert events[1]['_event_type'] == 'AddressUpdated'
def _jsonrpc_services(private_keys, verbose, poll_timeout):
print_communication = True if verbose > 7 else False
privatekey = private_keys[0]
address = privatekey_to_address(privatekey)
jsonrpc_client = JSONRPCClient(
host='0.0.0.0',
privkey=privatekey,
print_communication=print_communication,
)
patch_send_transaction(jsonrpc_client)
registry_path = get_contract_path('Registry.sol')
registry_contracts = compile_file(registry_path, libraries=dict())
log.info('Deploying registry contract')
registry_proxy = jsonrpc_client.deploy_solidity_contract(
address,
'Registry',
registry_contracts,
dict(),
tuple(),
timeout=poll_timeout,
)
registry_address = registry_proxy.address
blockchain_services = list()
for privkey in private_keys:
blockchain = BlockChainService(
privkey,
registry_address,
)
blockchain_services.append(blockchain)
return blockchain_services
def netting_channel_library(state):
netting_library_path = get_contract_path('NettingChannelLibrary.sol')
library_address = state.contract(
None,
path=netting_library_path,
language='solidity',
contract_name='NettingChannelLibrary',
)
return library_address
def netting_channel_library(state):
netting_library_path = get_contract_path('NettingChannelLibrary.sol')
library_address = state.contract(
None,
path=netting_library_path,
language='solidity',
contract_name='NettingChannelLibrary',
)
return library_address
def tester_nettingchannel_library_address(tester_state):
netting_library_path = get_contract_path('NettingChannelLibrary.sol')
library_address = tester_state.contract(
None,
path=netting_library_path,
language='solidity',
contract_name='NettingChannelLibrary',
)
tester_state.mine(number_of_blocks=1)
return library_address
def deploy_with_dependencies(contract_name, state, libraries=dict()):
dependencies = find_dependencies(
get_contract_path(contract_name))
dependency_names = [d.split('.')[0] for d in dependencies]
for key in list(libraries.keys()):
if not key in dependency_names:
libraries.pop(key)
log.DEV("in deploy_with_dependencies", contract=contract_name, dependencies=dependencies)
for dependency in dependencies:
# 'Contract's are included in 'Registry' and should not be deployed alone
if 'Contract' in dependency:
continue
log.DEV('deploying dependency', name=dependency)
log.DEV('known libraries', libraries=libraries)
deployed = state.abi_contract(None,
path=get_contract_path(dependency),
listen=False,
language='solidity',
libraries=libraries,
sender=DEFAULT_KEY,
)
libraries[dependency.split('.')[0]] = deployed.address.encode('hex')
state.mine()
log.DEV('deploying target', name=contract_name)
log.DEV('known libraries', libraries=libraries)
contract = state.abi_contract(
None,
path=get_contract_path(contract_name),
language='solidity',
libraries=libraries,
sender=DEFAULT_KEY,
)
libraries[contract_name.split('.')[0]] = contract.address.encode('hex')
state.mine()
return libraries
def registry(state, token, channel_manager_library, events):
registry_path = get_contract_path('Registry.sol')
return state.abi_contract(None,
path=registry_path,
language='solidity',
contract_name='Registry',
log_listener=events.append,
libraries={
'ChannelManagerLibrary':
channel_manager_library.encode('hex')
})
def channel_manager_library(state, netting_channel_library, settle_timeout,
token_address):
manager_library_path = get_contract_path('ChannelManagerLibrary.sol')
library_address = state.contract(None,
path=manager_library_path,
language='solidity',
contract_name='ChannelManagerLibrary',
libraries={
'NettingChannelLibrary':
netting_channel_library.encode('hex'),
})
return library_address
def channel_manager_library(state, netting_channel_library, settle_timeout, token_address):
manager_library_path = get_contract_path('ChannelManagerLibrary.sol')
library_address = state.contract(
None,
path=manager_library_path,
language='solidity',
contract_name='ChannelManagerLibrary',
libraries={
'NettingChannelLibrary': netting_channel_library.encode('hex'),
}
)
return library_address
def registry(state, token, channel_manager_library, events):
registry_path = get_contract_path('Registry.sol')
return state.abi_contract(
None,
path=registry_path,
language='solidity',
contract_name='Registry',
log_listener=events.append,
libraries={
'ChannelManagerLibrary': channel_manager_library.encode('hex')
}
)
def manager(state, token, channel_manager_library, events):
registry_path = get_contract_path('Registry.sol')
return state.abi_contract(None,
path=registry_path,
language='solidity',
constructor_parameters=[token.address],
contract_name='ChannelManagerContract',
log_listener=events.append,
libraries={
'ChannelManagerLibrary':
channel_manager_library.encode('hex'),
})
def tester_registry_address(tester_state,
tester_channelmanager_library_address):
registry_path = get_contract_path('Registry.sol')
registry_address = tester_state.contract(
None,
path=registry_path,
language='solidity',
contract_name='Registry',
libraries={
'ChannelManagerLibrary':
tester_channelmanager_library_address.encode('hex')
})
tester_state.mine(number_of_blocks=1)
return registry_address
def manager(state, token, channel_manager_library, events):
registry_path = get_contract_path('Registry.sol')
return state.abi_contract(
None,
path=registry_path,
language='solidity',
constructor_parameters=[token.address],
contract_name='ChannelManagerContract',
log_listener=events.append,
libraries={
'ChannelManagerLibrary': channel_manager_library.encode('hex'),
}
)
def channel(state, token, netting_channel_library, settle_timeout, events):
netting_contract_path = get_contract_path('ChannelManagerLibrary.sol')
abi = state.abi_contract(
None,
path=netting_contract_path,
language='solidity',
constructor_parameters=[token.address, tester.a0, tester.a1, settle_timeout],
contract_name='NettingChannelContract',
log_listener=events.append,
libraries={
'NettingChannelLibrary': netting_channel_library.encode('hex'),
}
)
return abi
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 tester_channelmanager_library_address(
tester_state, tester_nettingchannel_library_address):
channelmanager_library_path = get_contract_path(
'ChannelManagerLibrary.sol')
manager_address = tester_state.contract(
None,
path=channelmanager_library_path,
language='solidity',
contract_name='ChannelManagerLibrary',
libraries={
'NettingChannelLibrary':
tester_nettingchannel_library_address.encode('hex'),
})
tester_state.mine(number_of_blocks=1)
return manager_address
def token_address(asset_amount, state):
standard_token_path = get_contract_path('StandardToken.sol')
human_token_path = get_contract_path('HumanStandardToken.sol')
standard_token_address = state.contract(
None,
path=standard_token_path,
language='solidity',
)
human_libraries = {
'StandardToken': standard_token_address.encode('hex'),
}
human_token_proxy = state.abi_contract(
None,
path=human_token_path,
language='solidity',
libraries=human_libraries,
constructor_parameters=[asset_amount, 'raiden', 0, 'rd'],
)
state.mine()
return human_token_proxy.address
def token_address(asset_amount, state):
standard_token_path = get_contract_path('StandardToken.sol')
human_token_path = get_contract_path('HumanStandardToken.sol')
standard_token_address = state.contract(
None,
path=standard_token_path,
language='solidity',
)
human_libraries = {
'StandardToken': standard_token_address.encode('hex'),
}
human_token_proxy = state.abi_contract(
None,
path=human_token_path,
language='solidity',
libraries=human_libraries,
constructor_parameters=[asset_amount, 'raiden', 0, 'rd'],
)
state.mine()
return human_token_proxy.address
def find_dependencies(contract_file):
"""Resolve solidity dependencies depth first.
"""
dependencies = []
with open(contract_file) as f:
for line in f.readlines():
if line.startswith("import"):
dependency = line.split()[1].split('"')[1]
if dependency not in dependencies:
dependencies.extend(find_dependencies(get_contract_path(dependency)))
dependencies.append(dependency)
cleaned = []
for dependency in dependencies:
if dependency not in cleaned:
cleaned.append(dependency)
return cleaned
def channel(state, token, netting_channel_library, settle_timeout, events):
netting_contract_path = get_contract_path('ChannelManagerLibrary.sol')
abi = state.abi_contract(None,
path=netting_contract_path,
language='solidity',
constructor_parameters=[
token.address, tester.a0, tester.a1,
settle_timeout
],
contract_name='NettingChannelContract',
log_listener=events.append,
libraries={
'NettingChannelLibrary':
netting_channel_library.encode('hex'),
})
return abi
def deploy_contract(self,
contract_name,
contract_file,
constructor_parameters=None):
contract_path = get_contract_path(contract_file)
contracts = _solidity.compile_file(contract_path, libraries=dict())
log.info('Deploying "{}" contract'.format(contract_file))
proxy = self.client.deploy_solidity_contract(
self.node_address,
contract_name,
contracts,
dict(),
constructor_parameters,
timeout=self.poll_timeout,
)
return proxy.address
def create_and_distribute_token(state,
receivers,
name=None,
amount_per_receiver=1000):
proxy = state.abi_contract(
None,
path=get_contract_path(TARGETS['token']),
language='solidity',
listen=False,
sender=DEFAULT_KEY,
constructor_parameters=(
len(receivers) * amount_per_receiver,
name,
2,
name[:4].upper()
)
)
for receiver in receivers:
proxy.transfer(receiver, amount_per_receiver)
state.mine(number_of_blocks=1)
return (name, proxy.address.encode('hex'))
def create_token(self,
initial_alloc=10 ** 6,
name='raidentester',
symbol='RDT',
decimals=2,
timeout=60,
gasprice=denoms.shannon * 20,
auto_register=True):
"""Create a proxy for a new HumanStandardToken (ERC20), that is
initialized with Args(below).
Per default it will be registered with 'raiden'.
Args:
initial_alloc (int): amount of initial tokens.
name (str): human readable token name.
symbol (str): token shorthand symbol.
decimals (int): decimal places.
timeout (int): timeout in seconds for creation.
gasprice (int): gasprice for the creation transaction.
auto_register (boolean): if True(default), automatically register the asset with raiden.
Returns:
token_address: the hex encoded address of the new token/asset.
"""
# Deploy a new ERC20 token
token_proxy = self._chain.client.deploy_solidity_contract(
self._raiden.address, 'HumanStandardToken',
compile_file(get_contract_path('HumanStandardToken.sol')),
dict(),
(initial_alloc, name, decimals, symbol),
gasprice=gasprice,
timeout=timeout)
token_address = token_proxy.address.encode('hex')
if auto_register:
self.register_asset(token_address)
print("Successfully created {}the token '{}'.".format(
'and registered ' if auto_register else ' ',
name
))
return token_address
def test_endpointregistry(tester_state, tester_events):
account0 = tester.DEFAULT_ACCOUNT
sender = account0.encode('hex')
endpointregistry_path = get_contract_path('EndpointRegistry.sol')
registry_contract = tester_state.abi_contract(
None,
path=endpointregistry_path,
language='solidity',
log_listener=tester_events.append,
)
registry_contract.registerEndpoint('127.0.0.1:4001')
assert registry_contract.findAddressByEndpoint('127.0.0.1:4001') == sender
assert registry_contract.findEndpointByAddress(sender) == '127.0.0.1:4001'
registry_contract.registerEndpoint('192.168.0.1:4002')
assert registry_contract.findAddressByEndpoint('192.168.0.1:4002') == sender
assert registry_contract.findEndpointByAddress(sender) == '192.168.0.1:4002'
assert len(tester_events) == 2
assert tester_events[0]['_event_type'] == 'AddressRegistered'
assert tester_events[1]['_event_type'] == 'AddressRegistered'
def create_token(self,
initial_alloc=10 ** 6,
name='raidentester',
symbol='RDT',
decimals=2,
timeout=60,
gasprice=denoms.shannon * 20,
auto_register=True):
"""Create a proxy for a new HumanStandardToken (ERC20), that is
initialized with Args(below).
Per default it will be registered with 'raiden'.
Args:
initial_alloc (int): amount of initial tokens.
name (str): human readable token name.
symbol (str): token shorthand symbol.
decimals (int): decimal places.
timeout (int): timeout in seconds for creation.
gasprice (int): gasprice for the creation transaction.
auto_register (boolean): if True(default), automatically register the asset with raiden.
Returns:
token_address: the hex encoded address of the new token/asset.
"""
# Deploy a new ERC20 token
token_proxy = self._chain.client.deploy_solidity_contract(
self._raiden.address, 'HumanStandardToken',
compile_file(get_contract_path('HumanStandardToken.sol')),
dict(),
(initial_alloc, name, decimals, symbol),
gasprice=gasprice,
timeout=timeout)
token_address = token_proxy.address.encode('hex')
if auto_register:
self.register_asset(token_address)
print("Successfully created {}the token '{}'.".format('and registered ' if auto_register else ' ',
name))
return token_address
def test_endpointregistry():
registry_contract_path = get_contract_path('EndpointRegistry.sol')
events = []
state = tester.state()
assert state.block.number < 1150000
state.block.number = 1158001
assert state.block.number > 1150000
sender = tester.a0.encode('hex')
registry_contract = state.abi_contract(
None,
path=registry_contract_path,
language='solidity',
log_listener=events.append,
)
sender = tester.a0.encode('hex')
registry_contract.registerEndpoint('127.0.0.1:4001')
assert registry_contract.findAddressByEndpoint('127.0.0.1:4001') == sender
assert registry_contract.findEndpointByAddress(sender) == '127.0.0.1:4001'
registry_contract.registerEndpoint('192.168.0.1:4002')
assert registry_contract.findAddressByEndpoint('192.168.0.1:4002') == sender
assert registry_contract.findEndpointByAddress(sender) == '192.168.0.1:4002'
assert len(events) == 2
assert events[0]['_event_type'] == 'AddressRegistered'
assert events[1]['_event_type'] == 'AddressRegistered'
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
# -*- coding: utf8 -*-
from raiden.utils import (isaddress, pex, host_port_to_endpoint,
split_endpoint)
from raiden.blockchain.abi import get_contract_path
from ethereum import _solidity
discovery_contract_compiled = _solidity.compile_contract(
get_contract_path('EndpointRegistry.sol'),
'EndpointRegistry',
combined='abi',
)
DISCOVERY_CONTRACT_ABI = discovery_contract_compiled['abi']
class Discovery(object):
""" Mock mapping address: host, port """
def __init__(self):
self.nodeid_hostport = dict()
def register(self, nodeid, host, port):
assert isaddress(nodeid) # fixme, this is H(pubkey)
self.nodeid_hostport[nodeid] = (host, port)
def get(self, nodeid):
try:
return self.nodeid_hostport[nodeid]
except KeyError:
raise KeyError('Unknow address {}'.format(pex(nodeid)))
def nodeid_by_host_port(self, host_port):
for nodeid, value_hostport in self.nodeid_hostport.items():
def tester_deploy_contract(tester_state, private_key, contract_name,
contract_file, constructor_parameters=None):
contract_path = get_contract_path(contract_file)
all_contracts = _solidity.compile_file(contract_path, libraries=dict())
contract = all_contracts[contract_name]
contract_interface = contract['abi']
log.info('Deploying "{}" contract'.format(contract_file))
dependencies = deploy_dependencies_symbols(all_contracts)
deployment_order = dependencies_order_of_build(contract_name, dependencies)
log.info('Deploing dependencies: {}'.format(str(deployment_order)))
deployment_order.pop() # remove `contract_name` from the list
libraries = dict()
for deploy_contract in deployment_order:
dependency_contract = all_contracts[deploy_contract]
hex_bytecode = _solidity.solidity_resolve_symbols(
dependency_contract['bin_hex'],
libraries,
)
bytecode = decode_hex(hex_bytecode)
dependency_contract['bin_hex'] = hex_bytecode
dependency_contract['bin'] = bytecode
log.info('Creating contract {}'.format(deploy_contract))
contract_address = tester_state.evm(
bytecode,
private_key,
endowment=0,
)
tester_state.mine(number_of_blocks=1)
if len(tester_state.block.get_code(contract_address)) == 0:
raise Exception('Contract code empty')
libraries[deploy_contract] = encode_hex(contract_address)
hex_bytecode = _solidity.solidity_resolve_symbols(contract['bin_hex'], libraries)
bytecode = hex_bytecode.decode('hex')
contract['bin_hex'] = hex_bytecode
contract['bin'] = bytecode
if constructor_parameters:
translator = ContractTranslator(contract_interface)
parameters = translator.encode_constructor_arguments(constructor_parameters)
bytecode = contract['bin'] + parameters
else:
bytecode = contract['bin']
log.info('Creating contract {}'.format(contract_name))
contract_address = tester_state.evm(
bytecode,
private_key,
endowment=0,
)
tester_state.mine(number_of_blocks=1)
if len(tester_state.block.get_code(contract_address)) == 0:
raise Exception('Contract code empty')
return contract_address
def test_blockchain(private_keys, number_of_nodes, cluster, poll_timeout):
# pylint: disable=too-many-locals
addresses = [
privtoaddr(priv)
for priv in private_keys
]
privatekey = private_keys[0]
address = privtoaddr(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 allcontracts(contract_files):
return {
name_from_file(c): compile_contract(get_contract_path(c),
name_from_file(c))
for c in contract_files
}
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 netting_channel_abi():
netting_library_path = get_contract_path('ChannelManagerLibrary.sol')
netting_channel_compiled = compile_file(
netting_library_path)['NettingChannelContract']
netting_channel_abi = netting_channel_compiled['abi']
return netting_channel_abi
def token_abi():
human_token_path = get_contract_path('HumanStandardToken.sol')
human_compiled = compile_file(human_token_path, combined='abi')
return human_compiled['HumanStandardToken']['abi']
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 netting_channel_abi():
netting_library_path = get_contract_path('ChannelManagerLibrary.sol')
netting_channel_compiled = compile_file(netting_library_path)['NettingChannelContract']
netting_channel_abi = netting_channel_compiled['abi']
return netting_channel_abi
