def rundummy(ctx, num_validators, node_num, seed): # reduce key derivation iterations PBKDF2_CONSTANTS['c'] = 100 config = ctx.obj['config'] # create bootstrap node priv_key and enode bootstrap_node_privkey = mk_privkey('%d:udp:%d' % (seed, 0)) bootstrap_node_pubkey = privtopub_raw(bootstrap_node_privkey) assert len(bootstrap_node_pubkey) == 64, len(bootstrap_node_pubkey) base_port = 29870 host = b'0.0.0.0' bootstrap_node = host_port_pubkey_to_uri(host, base_port, bootstrap_node_pubkey) config['discovery']['bootstrap_nodes'] = [bootstrap_node] # create this node priv_key config['node']['privkey_hex'] = mk_privkey('%d:udp:%d' % (seed, node_num)).encode('hex') # create validator addresses validators = [privtoaddr(mk_privkey('%d:account:%d' % (seed, i))) for i in range(num_validators)] config['hdc']['validators'] = validators # create this node account account = Account.new(password='', key=mk_privkey('%d:account:%d' % (seed, node_num))) # set ports based on node config['discovery']['listen_port'] = base_port + node_num config['p2p']['listen_port'] = base_port + node_num config['p2p']['min_peers'] = 2 config['jsonrpc']['listen_port'] += node_num _start_app(account, config)
def signed_tx_example(): from ethereum.transactions import Transaction from pyethapp.accounts import mk_privkey, privtoaddr secret_seed = 'wow' privkey = mk_privkey(secret_seed) sender = privtoaddr(privkey) # fetch nonce nonce = quantity_decoder(JSONRPCClient().call('eth_getTransactionCount', address_encoder(sender), 'pending')) # create transaction tx = Transaction(nonce, default_gasprice, default_startgas, to=z_address, value=100, data='') tx.sign(privkey) tx_dict = tx.to_dict() tx_dict.pop('hash') res = JSONRPCClient().eth_sendTransaction(**tx_dict) if len(res) == 20: print 'contract created @', res.encode('hex') else: assert len(res) == 32 print 'tx hash', res.encode('hex')
def mk_enode(seed, node_num, host, port): print( host_port_pubkey_to_uri( host, port, privtopub_raw( mk_privkey( '%d:udp:%d' % (seed, node_num)))))
def _configure_node_network(config, num_validators, node_num, seed): assert node_num < num_validators # reduce key derivation iterations PBKDF2_CONSTANTS["c"] = 100 # create this node priv_key config["node"]["privkey_hex"] = mk_privkey("%d:udp:%d" % (seed, node_num)).encode("hex") # create validator addresses validators = [privtoaddr(mk_privkey("%d:account:%d" % (seed, i))) for i in range(num_validators)] config["hdc"]["validators"] = validators # create this node account account = Account.new(password="", key=mk_privkey("%d:account:%d" % (seed, node_num))) assert account.address in validators return config, account
def _configure_node_network(config, num_validators, node_num, seed): assert node_num < num_validators # reduce key derivation iterations PBKDF2_CONSTANTS['c'] = 100 # create this node priv_key config['node']['privkey_hex'] = mk_privkey('%d:udp:%d' % (seed, node_num)).encode('hex') # create validator addresses validators = [privtoaddr(mk_privkey('%d:account:%d' % (seed, i))) for i in range(num_validators)] config['hdc']['validators'] = validators # create this node account account = Account.new(password='', key=mk_privkey('%d:account:%d' % (seed, node_num))) assert account.address in validators return config, account
def tx_example(): """ unsigned txs is signed on the server which needs to know the secret key associated with the sending account it can be added in the config """ from pyethapp.accounts import mk_privkey, privtoaddr secret_seed = 'wow' sender = privtoaddr(mk_privkey(secret_seed)) res = JSONRPCClient().eth_sendTransaction(sender=sender, to=z_address, value=1000) if len(res) == 20: print 'contract created @', res.encode('hex') else: assert len(res) == 32 print 'tx hash', res.encode('hex')
def runlocal(ctx, num_validators, node_num, seed): assert node_num < num_validators # reduce key derivation iterations PBKDF2_CONSTANTS['c'] = 100 config = ctx.obj['config'] # create this node priv_key config['node']['privkey_hex'] = mk_privkey('%d:udp:%d' % (seed, node_num)).encode('hex') # create validator addresses validators = [privtoaddr(mk_privkey('%d:account:%d' % (seed, i))) for i in range(num_validators)] config['hdc']['validators'] = validators # create this node account account = Account.new(password='', key=mk_privkey('%d:account:%d' % (seed, node_num))) assert account.address in validators config['p2p']['min_peers'] = 2 _start_app(account, config, validators)
def signed_tx_example(): from ethereum.transactions import Transaction from pyethapp.accounts import mk_privkey, privtoaddr secret_seed = "wow" privkey = mk_privkey(secret_seed) sender = privtoaddr(privkey) # fetch nonce nonce = quantity_decoder(JSONRPCClient().call("eth_getTransactionCount", address_encoder(sender), "pending")) # create transaction tx = Transaction(nonce, default_gasprice, default_startgas, to=z_address, value=100, data="") tx.sign(privkey) tx_dict = tx.to_dict() tx_dict.pop("hash") res = JSONRPCClient().eth_sendTransaction(**tx_dict) if len(res) == 20: print "contract created @", res.encode("hex") else: assert len(res) == 32 print "tx hash", res.encode("hex")
def signed_tx_example(to=z_address, value=100): from ethereum.transactions import Transaction from pyethapp.accounts import mk_privkey, privtoaddr secret_seed = 'wow' privkey = mk_privkey(secret_seed) sender = privtoaddr(privkey) # fetch nonce nonce = quantity_decoder( JSONRPCClient().call('eth_getTransactionCount', address_encoder(sender), 'pending')) # create transaction tx = Transaction(nonce, default_gasprice, default_startgas, to=z_address, value=value, data='') tx.sign(privkey) tx_dict = tx.to_dict() tx_dict.pop('hash') res = JSONRPCClient().eth_sendTransaction(**tx_dict) if len(res) == 20: print 'contract created @', res.encode('hex') else: assert len(res) == 32 print 'tx hash', res.encode('hex')
def hydrachain_network(private_keys, base_port, base_datadir): """ Initializes a hydrachain network used for testing. """ # pylint: disable=too-many-locals from hydrachain.app import services, start_app, HPCApp import pyethapp.config as konfig gevent.get_hub().SYSTEM_ERROR = BaseException PBKDF2_CONSTANTS['c'] = 100 quantity = len(private_keys) def privkey_to_uri(private_key): host = b'0.0.0.0' pubkey = privtopub(private_key) return host_port_pubkey_to_uri(host, base_port, pubkey) addresses = [ privtoaddr(priv) for priv in private_keys ] bootstrap_nodes = [ privkey_to_uri(private_keys[0]), ] validator_keys = [ mk_privkey('raidenvalidator:{}'.format(position)) for position in range(quantity) ] validator_addresses = [ privtoaddr(validator_keys[position]) for position in range(quantity) ] alloc = { addr.encode('hex'): { 'balance': '1606938044258990275541962092341162602522202993782792835301376', } for addr in addresses } genesis = { 'nonce': '0x00006d6f7264656e', 'difficulty': '0x20000', 'mixhash': '0x00000000000000000000000000000000000000647572616c65787365646c6578', 'coinbase': '0x0000000000000000000000000000000000000000', 'timestamp': '0x00', 'parentHash': '0x0000000000000000000000000000000000000000000000000000000000000000', 'extraData': '0x', 'gasLimit': '0x5FEFD8', 'alloc': alloc, } all_apps = [] for number in range(quantity): port = base_port + number config = konfig.get_default_config(services + [HPCApp]) # del config['eth']['genesis_hash'] config = update_config_from_genesis_json(config, genesis) datadir = os.path.join(base_datadir, str(number)) konfig.setup_data_dir(datadir) account = Account.new( password='', key=validator_keys[number], ) config['data_dir'] = datadir config['node']['privkey_hex'] = private_keys[number].encode('hex') config['hdc']['validators'] = validator_addresses config['jsonrpc']['listen_port'] += number config['client_version_string'] = 'NODE{}'.format(number) # setting to 0 so that the CALLCODE opcode works at the start of the # network config['eth']['block']['HOMESTEAD_FORK_BLKNUM'] = 0 config['discovery']['bootstrap_nodes'] = bootstrap_nodes config['discovery']['listen_port'] = port config['p2p']['listen_port'] = port config['p2p']['min_peers'] = min(10, quantity - 1) config['p2p']['max_peers'] = quantity * 2 # only one of the nodes should have the Console service running if number != 0: config['deactivated_services'].append(Console.name) hydrachain_app = start_app(config, accounts=[account]) all_apps.append(hydrachain_app) return all_apps
def get_bootstrap_node(seed, base_port=29870, host=b"0.0.0.0"): # create bootstrap node priv_key and enode bootstrap_node_privkey = mk_privkey("%d:udp:%d" % (seed, 0)) bootstrap_node_pubkey = privtopub_raw(bootstrap_node_privkey) return host_port_pubkey_to_uri(host, base_port, bootstrap_node_pubkey)
def get_bootstrap_node(seed, base_port=29870, host=b'0.0.0.0'): # create bootstrap node priv_key and enode bootstrap_node_privkey = mk_privkey('%d:udp:%d' % (seed, 0)) bootstrap_node_pubkey = privtopub_raw(bootstrap_node_privkey) return host_port_pubkey_to_uri(host, base_port, bootstrap_node_pubkey)
def mk_enode(seed, node_num, host, port): print( host_port_pubkey_to_uri( host, port, privtopub_raw(mk_privkey('%d:udp:%d' % (seed, node_num)))))
def privkey(seed): return mk_privkey('42:account:{seed}'.format(seed=seed))
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'), )