def cached_genesis(request, blockchain_type):
"""
Deploy all contracts that are required by the fixtures into a tester and
then serialize the accounts into a genesis block.
Returns:
dict: A dictionary representing the genesis block.
"""
if not request.config.option.blockchain_cache:
return
# cannot cache for mock blockchain
if blockchain_type == 'mock':
return
# this will create the tester _and_ deploy the Registry
deploy_key = request.getfixturevalue('deploy_key')
private_keys = request.getfixturevalue('private_keys')
deploy_service, blockchain_services = _tester_services(
deploy_key,
private_keys,
request.getfixturevalue('tester_blockgas_limit'),
)
# create_network only registers the tokens,
# the contracts must be deployed previously
token_contract_addresses = _tokens_addresses(
request.getfixturevalue('token_amount'),
request.getfixturevalue('number_of_tokens'),
deploy_service,
blockchain_services,
)
raiden_apps = create_apps(
blockchain_services,
request.getfixturevalue('raiden_udp_ports'),
DummyTransport, # Do not use a UDP server to avoid port reuse in MacOSX
request.config.option.verbose,
request.getfixturevalue('send_ping_time'),
request.getfixturevalue('max_unresponsive_time'),
request.getfixturevalue('reveal_timeout'),
)
if 'raiden_network' in request.fixturenames:
create_network_channels(
raiden_apps,
token_contract_addresses,
request.getfixturevalue('channels_per_node'),
request.getfixturevalue('deposit'),
request.getfixturevalue('settle_timeout'),
)
elif 'raiden_chain' in request.fixturenames:
create_sequential_channels(
raiden_apps,
token_contract_addresses[0],
request.getfixturevalue('channels_per_node'),
request.getfixturevalue('deposit'),
request.getfixturevalue('settle_timeout'),
)
# else: a test that is not creating channels
for app in raiden_apps:
app.stop()
# save the state from the last block into a genesis dict
tester = blockchain_services[0].tester_state
tester.mine()
registry_address = blockchain_services[0].default_registry.address
genesis_alloc = dict()
for account_address in tester.block.state.to_dict():
account_alloc = tester.block.account_to_dict(account_address)
# code must be hex encoded without 0x prefix
account_alloc['code'] = safe_lstrip_hex(account_alloc.get('code', ''))
# account_to_dict returns accounts with nonce=0
account_alloc['nonce'] = tester.block.get_nonce(account_address)
genesis_alloc[account_address] = account_alloc
account_addresses = [
privatekey_to_address(key) for key in set(private_keys)
]
for address in account_addresses:
genesis_alloc[address]['balance'] = DEFAULT_BALANCE_BIN
alloc = {
safe_lstrip_hex(address_encoder(address_maybe_bin)): data
for address_maybe_bin, data in genesis_alloc.iteritems()
}
genesis = GENESIS_STUB.copy()
genesis['alloc'] = alloc
genesis['config']['defaultRegistryAddress'] = address_encoder(
registry_address)
genesis['config']['tokenAddresses'] = [
address_encoder(token_address)
for token_address in token_contract_addresses
]
return genesis
def cached_genesis(request, blockchain_type):
"""
Deploy all contracts that are required by the fixtures into a tester and
then serialize the accounts into a genesis block.
Returns:
dict: A dictionary representing the genesis block.
"""
if not request.config.option.blockchain_cache:
return
# cannot cache for mock blockchain
if blockchain_type == 'mock':
return
# this will create the tester _and_ deploy the Registry
deploy_key = request.getfixturevalue('deploy_key')
private_keys = request.getfixturevalue('private_keys')
deploy_service, blockchain_services = _tester_services(
deploy_key,
private_keys,
request.getfixturevalue('tester_blockgas_limit'),
)
# create_network only register the assets, the contracts must be deployed
# previously
asset_contract_addresses = _assets_addresses(
request.getfixturevalue('asset_amount'),
request.getfixturevalue('number_of_assets'),
deploy_service,
blockchain_services,
)
raiden_apps = create_apps(
blockchain_services,
request.getfixturevalue('transport_class'),
request.config.option.verbose,
request.getfixturevalue('send_ping_time'),
request.getfixturevalue('max_unresponsive_time'),
)
if 'raiden_network' in request.fixturenames:
create_network_channels(
raiden_apps,
asset_contract_addresses,
request.getfixturevalue('channels_per_node'),
request.getfixturevalue('deposit'),
request.getfixturevalue('settle_timeout'),
)
elif 'raiden_chain' in request.fixturenames:
create_sequential_channels(
raiden_apps,
asset_contract_addresses[0],
request.getfixturevalue('channels_per_node'),
request.getfixturevalue('deposit'),
request.getfixturevalue('settle_timeout'),
)
# else: a test that is not creating channels
for app in raiden_apps:
app.stop()
# save the state from the last block into a genesis dict
tester = blockchain_services[0].tester_state
tester.mine()
registry_address = blockchain_services[0].default_registry.address
genesis_alloc = dict()
for account_address in tester.block.state.to_dict():
account_alloc = tester.block.account_to_dict(account_address)
# code must be hex encoded without 0x prefix
account_alloc['code'] = safe_lstrip_hex(account_alloc.get('code', ''))
# account_to_dict returns accounts with nonce=0
account_alloc['nonce'] = tester.block.get_nonce(account_address)
genesis_alloc[account_address] = account_alloc
account_addresses = [
privatekey_to_address(key)
for key in set(private_keys)
]
for address in account_addresses:
genesis_alloc[address]['balance'] = DEFAULT_BALANCE_BIN
alloc = {
safe_lstrip_hex(address_encoder(address_maybe_bin)): data
for address_maybe_bin, data in genesis_alloc.iteritems()
}
genesis = GENESIS_STUB.copy()
genesis['alloc'] = alloc
genesis['config']['defaultRegistryAddress'] = address_encoder(registry_address)
genesis['config']['assetAddresses'] = [
address_encoder(asset_address)
for asset_address in asset_contract_addresses
]
return genesis
def deploy_all(token_groups=None):
if not token_groups:
token_groups.dict()
log.DEV( # pylint: disable=no-member
'default key',
raw=tester.DEFAULT_KEY,
enc=tester.DEFAULT_KEY.encode('hex'),
)
log.DEV( # pylint: disable=no-member
'default account',
raw=tester.DEFAULT_ACCOUNT,
enc=tester.DEFAULT_ACCOUNT.encode('hex'),
)
tester.DEFAULT_KEY = DEFAULT_KEY
tester.DEFAULT_ACCOUNT = DEFAULT_ACCOUNT
tester.keys[0] = DEFAULT_KEY
tester.accounts[0] = DEFAULT_ACCOUNT
log.DEV( # pylint: disable=no-member
'default key',
raw=tester.DEFAULT_KEY,
enc=tester.DEFAULT_KEY.encode('hex'),
)
log.DEV( # pylint: disable=no-member
'default account',
raw=tester.DEFAULT_ACCOUNT,
enc=tester.DEFAULT_ACCOUNT.encode('hex'),
)
state = tester.state(num_accounts=1)
log.DEV( # pylint: disable=no-member
'state',
coinbase=state.block.coinbase.encode('hex'),
balance=state.block.get_balance(DEFAULT_ACCOUNT),
)
tester.gas_limit = 10 * 10**6
state.block.number = 1158001
deployed = dict()
tokens = dict()
for name, group in token_groups.items():
token_name, address = create_and_distribute_token(state, group, name)
tokens[token_name] = address
deployed[token_name] = address
deployed.update(deploy_with_dependencies(TARGETS['token'], state))
libraries = deployed.copy()
deployed.update(
deploy_with_dependencies(TARGETS['registry'],
state,
libraries=libraries))
deployed.update(deploy_with_dependencies(TARGETS['discovery'], state))
genesis_alloc = dict()
for account_address in deployed.itervalues():
genesis_alloc[account_address] = account_alloc = dict()
for key, value in state.block.account_to_dict(
account_address).iteritems():
account_alloc[key] = safe_lstrip_hex(value)
raiden_flags = ('--registry-contract-address {Registry}'
' --discovery-contract-address {EndpointRegistry}').format(
**deployed)
blockchain_config = dict(
raiden_flags=raiden_flags,
token_groups=tokens,
)
blockchain_config['contract_addresses'] = deployed
return (genesis_alloc, blockchain_config)
def deploy_all(token_groups=None):
if not token_groups:
token_groups.dict()
log.DEV( # pylint: disable=no-member
'default key',
raw=tester.DEFAULT_KEY,
enc=tester.DEFAULT_KEY.encode('hex'),
)
log.DEV( # pylint: disable=no-member
'default account',
raw=tester.DEFAULT_ACCOUNT,
enc=tester.DEFAULT_ACCOUNT.encode('hex'),
)
tester.DEFAULT_KEY = DEFAULT_KEY
tester.DEFAULT_ACCOUNT = DEFAULT_ACCOUNT
tester.keys[0] = DEFAULT_KEY
tester.accounts[0] = DEFAULT_ACCOUNT
log.DEV( # pylint: disable=no-member
'default key',
raw=tester.DEFAULT_KEY,
enc=tester.DEFAULT_KEY.encode('hex'),
)
log.DEV( # pylint: disable=no-member
'default account',
raw=tester.DEFAULT_ACCOUNT,
enc=tester.DEFAULT_ACCOUNT.encode('hex'),
)
state = tester.state(num_accounts=1)
log.DEV( # pylint: disable=no-member
'state',
coinbase=state.block.coinbase.encode('hex'),
balance=state.block.get_balance(DEFAULT_ACCOUNT),
)
tester.gas_limit = 10 * 10 ** 6
state.block.number = 1158001
deployed = dict()
tokens = dict()
for name, group in token_groups.items():
token_name, address = create_and_distribute_token(state, group, name)
tokens[token_name] = address
deployed[token_name] = address
deployed.update(
deploy_with_dependencies(
TARGETS['token'],
state
)
)
libraries = deployed.copy()
deployed.update(
deploy_with_dependencies(
TARGETS['registry'],
state,
libraries=libraries
)
)
deployed.update(
deploy_with_dependencies(
TARGETS['discovery'],
state
)
)
genesis_alloc = dict()
for account_address in deployed.itervalues():
genesis_alloc[account_address] = account_alloc = dict()
for key, value in state.block.account_to_dict(account_address).iteritems():
account_alloc[key] = safe_lstrip_hex(value)
raiden_flags = (
'--registry_contract_address {Registry}'
' --discovery_contract_address {EndpointRegistry}'
).format(**deployed)
blockchain_config = dict(
raiden_flags=raiden_flags,
token_groups=tokens,
)
blockchain_config['contract_addresses'] = deployed
return (genesis_alloc, blockchain_config)
