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 if blockchain_type != 'geth': 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 register = True participants = [privatekey_to_address(privatekey) for privatekey in private_keys] token_contract_addresses = _token_addresses( request.getfixturevalue('token_amount'), request.getfixturevalue('number_of_tokens'), deploy_service, participants, register ) endpoint_discovery_address = deploy_service.deploy_contract( 'EndpointRegistry', 'EndpointRegistry.sol', ) endpoint_discovery_services = [ ContractDiscovery( chain.node_address, chain.discovery(endpoint_discovery_address), ) for chain in blockchain_services ] raiden_apps = create_apps( blockchain_services, endpoint_discovery_services, request.getfixturevalue('raiden_udp_ports'), DummyTransport, # Do not use a UDP server to avoid port reuse in MacOSX request.getfixturevalue('reveal_timeout'), request.getfixturevalue('settle_timeout'), request.getfixturevalue('database_paths'), request.getfixturevalue('retry_interval'), request.getfixturevalue('retries_before_backoff'), request.getfixturevalue('throttle_capacity'), request.getfixturevalue('throttle_fill_rate'), request.getfixturevalue('nat_invitation_timeout'), request.getfixturevalue('nat_keepalive_retries'), request.getfixturevalue('nat_keepalive_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(leave_channels=False) # 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) # Both keys and values of the account storage associative array # must now be encoded with 64 hex digits if account_alloc['storage']: account_alloc['storage'] = fix_tester_storage(account_alloc['storage']) # code must be hex encoded with 0x prefix account_alloc['code'] = account_alloc.get('code', '') # account_to_dict returns accounts with nonce=0 and the nonce must # be encoded with 16 hex digits account_alloc['nonce'] = '0x%016x' % tester.block.get_nonce(account_address) genesis_alloc[account_address] = account_alloc all_keys = set(private_keys) all_keys.add(deploy_key) all_keys = sorted(all_keys) account_addresses = [ privatekey_to_address(key) for key in all_keys ] for address in account_addresses: genesis_alloc[address]['balance'] = DEFAULT_BALANCE_BIN alloc = { address_encoder(address_maybe_bin): data for address_maybe_bin, data in genesis_alloc.iteritems() } genesis = GENESIS_STUB.copy() genesis['config']['clique'] = {'period': 1, 'epoch': 30000} random_marker = request.getfixturevalue('random_marker') genesis['extraData'] = clique_extradata( random_marker, address_encoder(account_addresses[0])[2:], ) genesis['alloc'] = alloc genesis['config']['defaultDiscoveryAddress'] = address_encoder(endpoint_discovery_address) 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): """ 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 # this will create the tester _and_ deploy the Registry deploy_key = request.getfixturevalue('deploy_key') private_keys = request.getfixturevalue('private_keys') registry, deploy_service, blockchain_services = _tester_services( deploy_key, private_keys, request.getfixturevalue('tester_blockgas_limit'), ) registry_address = registry.address # create_network only registers the tokens, # the contracts must be deployed previously register = True participants = [privatekey_to_address(privatekey) for privatekey in private_keys] token_contract_addresses = _token_addresses( request.getfixturevalue('token_amount'), request.getfixturevalue('number_of_tokens'), deploy_service, registry, participants, register ) endpoint_discovery_address = deploy_service.deploy_contract( 'EndpointRegistry', get_contract_path('EndpointRegistry.sol'), ) endpoint_discovery_services = [ ContractDiscovery( chain.node_address, chain.discovery(endpoint_discovery_address), ) for chain in blockchain_services ] raiden_apps = create_apps( blockchain_services, endpoint_discovery_services, registry_address, request.getfixturevalue('raiden_udp_ports'), DummyTransport, # Do not use a UDP server to avoid port reuse in MacOSX request.getfixturevalue('reveal_timeout'), request.getfixturevalue('settle_timeout'), request.getfixturevalue('database_paths'), request.getfixturevalue('retry_interval'), request.getfixturevalue('retries_before_backoff'), request.getfixturevalue('throttle_capacity'), request.getfixturevalue('throttle_fill_rate'), request.getfixturevalue('nat_invitation_timeout'), request.getfixturevalue('nat_keepalive_retries'), request.getfixturevalue('nat_keepalive_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(leave_channels=False) # save the state from the last block into a genesis dict tester = blockchain_services[0].tester_chain tester.mine() genesis_alloc = dict() for account_address in tester.head_state.to_dict(): account_alloc = tester.head_state.account_to_dict(account_address) # Both keys and values of the account storage associative array # must now be encoded with 64 hex digits if account_alloc['storage']: account_alloc['storage'] = fix_tester_storage(account_alloc['storage']) # code must be hex encoded with 0x prefix account_alloc['code'] = account_alloc.get('code', '') # account_to_dict returns accounts with nonce=0 and the nonce must # be encoded with 16 hex digits account_alloc['nonce'] = '0x%016x' % tester.head_state.get_nonce(account_address) genesis_alloc[account_address] = account_alloc all_keys = set(private_keys) all_keys.add(deploy_key) all_keys = sorted(all_keys) account_addresses = [ privatekey_to_address(key) for key in all_keys ] for address in account_addresses: address_hex = hexlify(address).decode() genesis_alloc[address_hex]['balance'] = DEFAULT_BALANCE_BIN genesis = GENESIS_STUB.copy() genesis['config']['clique'] = {'period': 1, 'epoch': 30000} random_marker = request.getfixturevalue('random_marker') genesis['extraData'] = clique_extradata( random_marker, address_encoder(account_addresses[0])[2:], ) genesis['alloc'] = genesis_alloc genesis['config']['defaultDiscoveryAddress'] = address_encoder(endpoint_discovery_address) genesis['config']['defaultRegistryAddress'] = address_encoder(registry_address) genesis['config']['tokenAddresses'] = [ address_encoder(token_address) for token_address in token_contract_addresses ] return genesis
def deploy_and_open_channel_alloc(deployment_key): """ Compiles, deploys and dumps a minimal raiden smart contract environment for use in a genesis block. This will: - deploy the raiden Registry contract stack - deploy a token contract - open a channel for the TEST_ACCOUNT address - deploy the EndpointRegistry/discovery contract - register a known value for the TEST_ACCOUNT address - dump the complete state in a genesis['alloc'] compatible format - return the state dump and the contract addresses """ deployment_key_bin = deployment_key.decode('hex') state = tester_state(deployment_key_bin, [deployment_key_bin], 6 * 10**6) registry_address = tester_deploy_contract( state, deployment_key_bin, 'Registry', get_contract_path('Registry.sol'), ) discovery_address = tester_deploy_contract( state, deployment_key_bin, 'EndpointRegistry', get_contract_path('EndpointRegistry.sol'), ) client = BlockChainServiceTesterMock( deployment_key_bin, state, ) registry = client.registry(registry_address) token_address = client.deploy_and_register_token( registry, 'HumanStandardToken', get_contract_path('HumanStandardToken.sol'), constructor_parameters=(100, 'smoketesttoken', 2, 'RST')) manager = registry.manager_by_token(token_address) assert manager.private_key == deployment_key_bin our_address = TEST_ACCOUNT['address'] channel_address = manager.new_netting_channel( our_address.decode('hex'), TEST_PARTNER_ADDRESS.decode('hex'), 50) client.token(token_address).approve(channel_address, TEST_DEPOSIT_AMOUNT) channel = NettingChannelTesterMock(state, deployment_key_bin, channel_address) channel.deposit(TEST_DEPOSIT_AMOUNT) discovery = client.discovery(discovery_address) discovery.proxy.registerEndpoint(TEST_ENDPOINT) contracts = dict( registry_address=registry_address, token_address=token_address, discovery_address=discovery_address, channel_address=channel_address, ) for k, v in contracts.iteritems(): contracts[k] = hexlify(v) alloc = dict() # preserve all accounts and contracts for address in state.block.state.to_dict().keys(): address = hexlify(address) alloc[address] = state.block.account_to_dict(address) for account, content in alloc.iteritems(): alloc[account]['storage'] = fix_tester_storage(content['storage']) return dict( alloc=alloc, contracts=contracts, )
def deploy_and_open_channel_alloc(deployment_key): """ Compiles, deploys and dumps a minimal raiden smart contract environment for use in a genesis block. This will: - deploy the raiden Registry contract stack - deploy a token contract - open a channel for the TEST_ACCOUNT address - deploy the EndpointRegistry/discovery contract - register a known value for the TEST_ACCOUNT address - dump the complete state in a genesis['alloc'] compatible format - return the state dump and the contract addresses """ deployment_key_bin = unhexlify(deployment_key) state = create_tester_chain( deployment_key_bin, [deployment_key_bin], 6 * 10 ** 6 ) registry_address = tester_deploy_contract( state, deployment_key_bin, 'Registry', get_contract_path('Registry.sol'), ) discovery_address = tester_deploy_contract( state, deployment_key_bin, 'EndpointRegistry', get_contract_path('EndpointRegistry.sol'), ) client = BlockChainServiceTesterMock( deployment_key_bin, state, ) registry = client.registry(registry_address) token_address = client.deploy_and_register_token( registry, 'HumanStandardToken', get_contract_path('HumanStandardToken.sol'), constructor_parameters=(100, 'smoketesttoken', 2, 'RST') ) manager = registry.manager_by_token(token_address) assert manager.private_key == deployment_key_bin channel_address = manager.new_netting_channel( unhexlify(TEST_PARTNER_ADDRESS), 50 ) client.token(token_address).approve(channel_address, TEST_DEPOSIT_AMOUNT) channel = NettingChannelTesterMock( state, deployment_key_bin, channel_address ) channel.deposit(TEST_DEPOSIT_AMOUNT) discovery = client.discovery(discovery_address) discovery.proxy.registerEndpoint(TEST_ENDPOINT) contracts = dict( registry_address=address_encoder(registry_address), token_address=address_encoder(token_address), discovery_address=address_encoder(discovery_address), channel_address=address_encoder(channel_address), ) alloc = dict() # preserve all accounts and contracts for address in state.head_state.to_dict().keys(): alloc[address] = state.head_state.account_to_dict(address) for account, content in alloc.items(): alloc[account]['storage'] = fix_tester_storage(content['storage']) return dict( alloc=alloc, contracts=contracts, )