def test_unlock(keystore, password, privkey, uuid): account = Account(keystore) assert account.locked account.unlock(password) assert not account.locked assert account.privkey == privkey assert account.address == privtoaddr(privkey)
def test_address(keystore, password, privkey): keystore_wo_address = keystore.copy() keystore_wo_address.pop('address') account = Account(keystore_wo_address) assert account.address is None account.unlock(password) account.lock() assert account.address == privtoaddr(privkey)
def start(self): super(TestApp, self).start() log.debug('adding test accounts') # high balance account self.services.accounts.add_account(Account.new('', tester.keys[0]), store=False) # low balance account self.services.accounts.add_account(Account.new('', tester.keys[1]), store=False) # locked account locked_account = Account.new('', tester.keys[2]) locked_account.lock() self.services.accounts.add_account(locked_account, store=False) assert set(acct.address for acct in self.services.accounts) == set(tester.accounts[:3])
def start(self): super(TestApp, self).start() log.debug("adding test accounts") # high balance account self.services.accounts.add_account(Account.new("", tester.keys[0]), store=False) # low balance account self.services.accounts.add_account(Account.new("", tester.keys[1]), store=False) # locked account locked_account = Account.new("", tester.keys[2]) locked_account.lock() self.services.accounts.add_account(locked_account, store=False) assert set(acct.address for acct in self.services.accounts) == set(tester.accounts[:3])
def start(self): super(EdgeChainApp, self).start() log.debug('adding test accounts') self.services.accounts.add_account(Account.new('ADMIN', tester.keys[0]), store=False) self.services.accounts.add_account(Account.new('MES', tester.keys[1]), store=False) self.services.accounts.add_account(Account.new('REQUESTER1', tester.keys[2]), store=False) self.services.accounts.add_account(Account.new('REQUESTER2', tester.keys[3]), store=False)
def test_store_overwrite(app, account): s = app.services.accounts uuid = account.uuid account.uuid = None account.path = os.path.join(app.config["accounts"]["keystore_dir"], "account1") account2 = Account(account.keystore) account2.path = os.path.join(app.config["accounts"]["keystore_dir"], "account2") s.add_account(account, store=True) with pytest.raises(IOError): s.add_account(account, store=True) s.add_account(account2, store=True) account.uuid = uuid account.path = None
def test_store_overwrite(app, account): s = app.services.accounts uuid = account.uuid account.uuid = None account.path = os.path.join(app.config['accounts']['keystore_dir'], 'account1') account2 = Account(account.keystore) account2.path = os.path.join(app.config['accounts']['keystore_dir'], 'account2') s.add_account(account, store=True) with pytest.raises(IOError): s.add_account(account, store=True) s.add_account(account2, store=True) account.uuid = uuid account.path = None
def start(self): super(TestApp, self).start() log.debug('adding test accounts') # high balance account self.services.accounts.add_account(Account.new('', tester.keys[0]), store=False) # low balance account self.services.accounts.add_account(Account.new('', tester.keys[1]), store=False) # locked account locked_account = Account.new('', tester.keys[2]) locked_account.lock() self.services.accounts.add_account(locked_account, store=False) self.privkey = None assert set(acct.address for acct in self.services.accounts) == set(tester.accounts[:3]) test_transport = TestTransport(call_func=self.rpc_request) self.client = JSONRPCClient(transport=test_transport)
def test_locked(keystore, uuid): account = Account(keystore) assert account.locked assert account.address.encode('hex') == keystore['address'] assert account.privkey is None assert account.pubkey is None assert account.uuid == uuid keystore2 = keystore.copy() keystore2.pop('address') account = Account(keystore2) assert account.locked assert account.address is None assert account.privkey is None assert account.pubkey is None assert account.uuid == uuid
def call(keyfile, password): print("------------------------------------------------------------------") print("Trying {}".format(password)) print("------------------------------------------------------------------") try: Account.load(keyfile, password=password) except ValueError as e: if str(e) == 'MAC mismatch. Password incorrect?': return False # else raise, as we got unexpected error raise e print("Found password: {}".format(password)) return True
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 player_roll_dice(self, bet_size_ether, chances, wallet_path, wallet_password): """ Work in progress: https://github.com/AndreMiras/EtherollApp/issues/1 """ roll_under = chances value_wei = w3.toWei(bet_size_ether, 'ether') gas = 310000 gas_price = w3.toWei(4, 'gwei') # since Account.load is hanging while decrypting the password # we set password to None and use `w3.eth.account.decrypt` instead account = Account.load(wallet_path, password=None) from_address_normalized = checksum_encode(account.address) nonce = self.web3.eth.getTransactionCount(from_address_normalized) transaction = { # 'chainId': ChainID.ROPSTEN.value, 'chainId': int(self.web3.net.version), 'gas': gas, 'gasPrice': gas_price, 'nonce': nonce, 'value': value_wei, } transaction = self.contract.functions.playerRollDice( roll_under).buildTransaction(transaction) encrypted_key = open(wallet_path).read() private_key = w3.eth.account.decrypt(encrypted_key, wallet_password) signed_tx = self.web3.eth.account.signTransaction( transaction, private_key) tx_hash = self.web3.eth.sendRawTransaction(signed_tx.rawTransaction) print("tx_hash:", tx_hash.hex()) return tx_hash
def get_privkey(self, address, password=None): """Find the keystore file for an account, unlock it and get the private key :param str address: The Ethereum address for which to find the keyfile in the system :param str password: Mostly for testing purposes. A password can be provided as the function argument here. If it's not then the user is interactively queried for one. :return str: The private key associated with the address """ if address.startswith('0x'): address = address[2:] address = address.lower() if not self.address_in_keystore(address): raise ValueError("Keystore file not found for %s" % address) with open(self.accounts[address]) as data_file: data = json.load(data_file) # Since file was found prompt for a password if not already given if password is None: password = getpass.getpass("Enter the password to unlock %s: " % address) acc = Account(data, password, self.accounts[address]) return acc.privkey
def create_account_helper(self, password): # reduces key derivation iterations to speed up creation PBKDF2_CONSTANTS['c'] = 1 wallet_path = os.path.join(self.keystore_dir, 'wallet.json') account = Account.new(password, path=wallet_path) with open(account.path, 'w') as f: f.write(account.dump()) return account
def test_store_dir(app, account): s = app.services.accounts uuid = account.uuid account.uuid = None paths = [os.path.join(app.config['accounts']['keystore_dir'], p) for p in [ 'some/sub/dir/account1', 'some/sub/dir/account2', 'account1', ]] for path in paths: new_account = Account(account.keystore, path=path) s.add_account(new_account) for path in paths: new_account = Account(account.keystore, path=path) with pytest.raises(IOError): s.add_account(new_account) account.uuid = uuid
def private_to_account(ctx, privatekey, password): # privatekey is provided in the console, so it's expected to be hexadecimal privatekey = safe_address_decode(privatekey) # cast the values to bytes because it is the expected type in the Crypto library password = bytes(password) privkey = bytes(privatekey) account = Account.new(password, key=privkey) print account.dump()
def test_store_private(app, account, password): s = app.services.accounts account.path = os.path.join(app.config["accounts"]["keystore_dir"], "account1") s.add_account(account, include_id=False, include_address=False) account_reloaded = Account.load(account.path) assert account_reloaded.address is None assert account_reloaded.uuid is None account_reloaded.unlock(password) assert account_reloaded.address == account.address assert account_reloaded.uuid is None account.path = None
def test_store_absolute(app, account): s = app.services.accounts tmpdir = tempfile.mkdtemp() account.path = os.path.join(tmpdir, "account1") assert os.path.isabs(account.path) s.add_account(account) assert os.path.exists(account.path) account_reloaded = Account.load(account.path) assert account_reloaded.address == account.address shutil.rmtree(tmpdir) account.path = None
def test_store_absolute(app, account): s = app.services.accounts tmpdir = tempfile.mkdtemp() account.path = os.path.join(tmpdir, 'account1') assert os.path.isabs(account.path) s.add_account(account) assert os.path.exists(account.path) account_reloaded = Account.load(account.path) assert account_reloaded.address == account.address shutil.rmtree(tmpdir) account.path = None
def test_pyethapp(self): from pyethapp.accounts import Account from ethereum_utils import AccountUtils AccountUtils.patch_ethereum_tools_keys() password = "******" uuid = None account = Account.new(password, uuid=uuid) # restore iterations address = account.address.hex() self.assertIsNotNone(account) self.assertIsNotNone(address)
def test_store_private(app, account, password): s = app.services.accounts account.path = os.path.join(app.config['accounts']['keystore_dir'], 'account1') s.add_account(account, include_id=False, include_address=False) account_reloaded = Account.load(account.path) assert account_reloaded.address is None assert account_reloaded.uuid is None account_reloaded.unlock(password) assert account_reloaded.address == account.address assert account_reloaded.uuid is None account.path = None
def new_account(self, password): """ Creates an account on the disk and returns it. """ # lazy loading from pyethapp.accounts import Account account = Account.new(password, uuid=None) account.path = os.path.join( self.app.services.accounts.keystore_dir, account.address.hex()) self.app.services.accounts.add_account(account) return account
def start_app(config, accounts): # create app app = HPCApp(config) # development mode if False: gevent.get_hub().SYSTEM_ERROR = BaseException if config['test_privkeys']: # init accounts first, as we need (and set by copy) the coinbase early FIXME genesis_config = dict(alloc=dict()) for privkey in config['test_privkeys']: assert len(privkey) == 32 address = privtoaddr(privkey) account = Account.new(password='', key=privkey) accounts.append(account) # add to genesis alloc genesis_config['alloc'][address] = {'wei': config['test_privkeys_endowment']} if config['test_privkeys'] and config['eth'].get('genesis_hash'): del config['eth']['genesis_hash'] konfig.update_config_from_genesis_json(config, genesis_config) # dump config pyethapp_app.dump_config(config) if AccountsService in services: AccountsService.register_with_app(app) # add account for account in accounts: app.services.accounts.add_account(account, store=False) if config['hdc']['validators']: assert app.services.accounts.coinbase in config['hdc']['validators'] # register services for service in services: assert issubclass(service, BaseService) if service.name not in app.config['deactivated_services'] + [AccountsService.name]: assert service.name not in app.services service.register_with_app(app) assert hasattr(app.services, service.name) # start app log.info('starting') app.start() for cb in config['post_app_start_callbacks']: cb(app) return app
def test_store(app, account): s = app.services.accounts account.path = os.path.join(app.config['accounts']['keystore_dir'], 'account1') s.add_account(account, include_id=True, include_address=True) assert os.path.exists(account.path) account_reloaded = Account.load(account.path) assert account_reloaded.uuid is not None assert account_reloaded.address is not None assert account_reloaded.uuid == account.uuid assert account_reloaded.address == account.address assert account_reloaded.privkey is None assert account_reloaded.path == account.path assert account.privkey is not None account.path = None
def test_store(app, account): s = app.services.accounts account.path = os.path.join(app.config["accounts"]["keystore_dir"], "account1") s.add_account(account, include_id=True, include_address=True) assert os.path.exists(account.path) account_reloaded = Account.load(account.path) assert account_reloaded.uuid is not None assert account_reloaded.address is not None assert account_reloaded.uuid == account.uuid assert account_reloaded.address == account.address assert account_reloaded.privkey is None assert account_reloaded.path == account.path assert account.privkey is not None account.path = None
def test_pyethapp(self): from pyethapp.accounts import Account from ethereum.tools.keys import PBKDF2_CONSTANTS # backup iterations iterations_backup = PBKDF2_CONSTANTS['c'] # speeds up the test PBKDF2_CONSTANTS['c'] = 100 password = "******" uuid = None account = Account.new(password, uuid=uuid) # restore iterations PBKDF2_CONSTANTS['c'] = iterations_backup address = account.address.encode('hex') self.assertIsNotNone(account) self.assertIsNotNone(address)
def test_account_sorting(app): keystore_dummy = {} paths = [ '/absolute/path/b', '/absolute/path/c', '/absolute/path/letter/e', '/absolute/path/letter/d', '/letter/f', '/absolute/path/a', None ] # paths_sortable = [(x or "") for x in paths] min_value = MinType() paths_sorted = sorted(paths, key=lambda x: min_value if x is None else x) # paths_sorted = sorted(paths, key=lambda x: (x is None, x)) s = app.services.accounts for path in paths: s.add_account(Account(keystore_dummy, path=path), store=False) assert [account.path for account in s.accounts] == paths_sorted
def test_account_sorting(app): keystore_dummy = {} paths = [ '/absolute/path/b', '/absolute/path/c', '/absolute/path/letter/e', '/absolute/path/letter/d', '/letter/f', '/absolute/path/a', None ] paths_sorted = sorted(paths) s = app.services.accounts for path in paths: s.add_account(Account(keystore_dummy, path=path), store=False) assert [account.path for account in s.accounts] == paths_sorted assert [s.find(str(i)).path for i in xrange(1, len(paths) + 1)] == paths_sorted
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 new_account_helper(password, security_ratio=None): """ Helper method for creating an account in memory. Returns the created account. security_ratio is a ratio of the default PBKDF2 iterations. Ranging from 1 to 100 means 100% of the iterations. """ # TODO: perform validation on security_ratio (within allowed range) if security_ratio: default_iterations = PBKDF2_CONSTANTS["c"] new_iterations = int((default_iterations * security_ratio) / 100) PBKDF2_CONSTANTS["c"] = new_iterations uuid = None account = Account.new(password, uuid=uuid) # reverts to previous iterations if security_ratio: PBKDF2_CONSTANTS["c"] = default_iterations return 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 __init__(self, privkey, validators, simenv=None): self.config = copy.deepcopy(hdc_service.ChainService.default_config) self.config['db'] = dict(path='_db') self.config['data_dir'] = tempfile.mkdtemp() self.config['hdc']['validators'] = validators self.simenv = simenv self.services = self.Services() self.services.db = EphemDB() self.services.accounts = AccountsService(self) self.services.peermanager = PeerManagerMock(self) account = Account.new(password='', key=privkey) self.services.accounts.add_account(account, store=False) if simenv: self.services.chainservice = SimChainService(self, simenv=simenv) else: self.services.chainservice = hdc_service.ChainService(self) self.isactive = True
def __init__(self, privkey, validators, simenv=None): self.config = copy.deepcopy(hdc_service.ChainService.default_config) self.config["db"] = dict(path="_db") self.config["data_dir"] = tempfile.mkdtemp() self.config["hdc"]["validators"] = validators initial_alloc = dict((a, dict(wei=2 ** 200)) for a in validators) self.config["eth"]["block"]["GENESIS_INITIAL_ALLOC"] = initial_alloc self.simenv = simenv self.services = self.Services() self.services.db = EphemDB() self.services.accounts = AccountsService(self) self.services.peermanager = PeerManagerMock(self) account = Account.new(password="", key=privkey) self.services.accounts.add_account(account, store=False) if simenv: self.services.chainservice = SimChainService(self, simenv=simenv) else: self.services.chainservice = hdc_service.ChainService(self) self.isactive = True
def __init__(self, privkey, validators, simenv=None): self.config = copy.deepcopy(hdc_service.ChainService.default_config) self.config['db'] = dict(path='_db') self.config['data_dir'] = tempfile.mkdtemp() self.config['hdc']['validators'] = validators initial_alloc = dict((a, dict(wei=2 ** 200)) for a in validators) self.config['eth']['block']['GENESIS_INITIAL_ALLOC'] = initial_alloc self.simenv = simenv self.services = self.Services() self.services.db = EphemDB() self.services.accounts = AccountsService(self) self.services.peermanager = PeerManagerMock(self) account = Account.new(password='', key=privkey) self.services.accounts.add_account(account, store=False) if simenv: self.services.chainservice = SimChainService(self, simenv=simenv) else: self.services.chainservice = hdc_service.ChainService(self) self.isactive = True
def player_roll_dice(self, bet_size_ether, chances, wallet_path, wallet_password, gas_price_gwei=DEFAULT_GAS_PRICE_GWEI): """ Signs and broadcasts `playerRollDice` transaction. Returns transaction hash. """ roll_under = chances # `w3.toWei` one has some issues on Android, see: # https://github.com/AndreMiras/EtherollApp/issues/77 # value_wei = w3.toWei(bet_size_ether, 'ether') value_wei = int(bet_size_ether * 1e18) gas = 310000 gas_price = w3.toWei(gas_price_gwei, 'gwei') # since Account.load is hanging while decrypting the password # we set password to None and use `w3.eth.account.decrypt` instead account = Account.load(wallet_path, password=None) from_address_normalized = checksum_encode(account.address) nonce = self.web3.eth.getTransactionCount(from_address_normalized) transaction = { 'chainId': self.chain_id.value, 'gas': gas, 'gasPrice': gas_price, 'nonce': nonce, 'value': value_wei, } transaction = self.contract.functions.playerRollDice( roll_under).buildTransaction(transaction) private_key = AccountUtils.get_private_key(wallet_path, wallet_password) signed_tx = self.web3.eth.account.signTransaction( transaction, private_key) tx_hash = self.web3.eth.sendRawTransaction(signed_tx.rawTransaction) return tx_hash
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 test_unlock_wrong(keystore, password, privkey, uuid): account = Account(keystore) assert account.locked with pytest.raises(ValueError): account.unlock(password + '1234') assert account.locked with pytest.raises(ValueError): account.unlock('4321' + password) assert account.locked with pytest.raises(ValueError): account.unlock(password[:len(password) / 2]) assert account.locked account.unlock(password) assert not account.locked account.unlock(password + 'asdf') assert not account.locked account.unlock(password + '1234') assert not account.locked
def account(privkey, password, uuid): return Account.new(password, privkey, uuid)
def __init__(self, privkey): self.services = self.Services() self.services.db = EphemDB() self.services.accounts = AccountsService(self) account = Account.new(password='', key=privkey) self.services.accounts.add_account(account, store=False)
def create_hydrachain_cluster(private_keys, hydrachain_private_keys, p2p_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 def privkey_to_uri(private_key): host = b'0.0.0.0' pubkey = privtopub(private_key) return host_port_pubkey_to_uri(host, p2p_base_port, pubkey) account_addresses = [ privtoaddr(priv) for priv in private_keys ] alloc = { encode_hex(address): { 'balance': DEFAULT_BALANCE, } for address in account_addresses } genesis = { 'nonce': '0x00006d6f7264656e', 'difficulty': '0x20000', 'mixhash': '0x00000000000000000000000000000000000000647572616c65787365646c6578', 'coinbase': '0x0000000000000000000000000000000000000000', 'timestamp': '0x00', 'parentHash': '0x0000000000000000000000000000000000000000000000000000000000000000', 'extraData': '0x', 'gasLimit': GAS_LIMIT_HEX, 'alloc': alloc, } bootstrap_nodes = [ privkey_to_uri(hydrachain_private_keys[0]), ] validators_addresses = [ privtoaddr(private_key) for private_key in hydrachain_private_keys ] all_apps = [] for number, private_key in enumerate(hydrachain_private_keys): config = konfig.get_default_config(services + [HPCApp]) 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=private_key, ) config['data_dir'] = datadir config['hdc']['validators'] = validators_addresses config['node']['privkey_hex'] = encode_hex(private_key) 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'] = p2p_base_port + number config['p2p']['listen_port'] = p2p_base_port + number config['p2p']['min_peers'] = min(10, len(hydrachain_private_keys) - 1) config['p2p']['max_peers'] = len(hydrachain_private_keys) * 2 # only one of the nodes should have the Console service running if number != 0 and Console.name not in config['deactivated_services']: config['deactivated_services'].append(Console.name) hydrachain_app = start_app(config, accounts=[account]) all_apps.append(hydrachain_app) hydrachain_wait(private_keys, len(hydrachain_private_keys) - 1) return all_apps
def account_file(): account = Account.new('', key="1" * 64) print account.dump()
def hydrachain_create_blockchain(private_keys, hydrachain_private_keys, p2p_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 def privkey_to_uri(private_key): host = b'0.0.0.0' pubkey = privtopub(private_key) return host_port_pubkey_to_uri(host, p2p_base_port, pubkey) account_addresses = [ privatekey_to_address(priv) for priv in private_keys ] alloc = { encode_hex(address): { 'balance': DEFAULT_BALANCE_BIN, } for address in account_addresses } genesis = { 'nonce': '0x00006d6f7264656e', 'difficulty': '0x20000', 'mixhash': '0x00000000000000000000000000000000000000647572616c65787365646c6578', 'coinbase': '0x0000000000000000000000000000000000000000', 'timestamp': '0x00', 'parentHash': '0x0000000000000000000000000000000000000000000000000000000000000000', 'extraData': '0x', 'gasLimit': GAS_LIMIT_HEX, 'alloc': alloc, } bootstrap_nodes = [ privkey_to_uri(hydrachain_private_keys[0]), ] validators_addresses = [ privatekey_to_address(private_key) for private_key in hydrachain_private_keys ] all_apps = [] for number, private_key in enumerate(hydrachain_private_keys): config = konfig.get_default_config(services + [HPCApp]) 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=private_key, ) config['data_dir'] = datadir config['hdc']['validators'] = validators_addresses config['node']['privkey_hex'] = encode_hex(private_key) 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'] = p2p_base_port + number config['p2p']['listen_port'] = p2p_base_port + number config['p2p']['min_peers'] = min(10, len(hydrachain_private_keys) - 1) config['p2p']['max_peers'] = len(hydrachain_private_keys) * 2 # only one of the nodes should have the Console service running if number != 0 and Console.name not in config['deactivated_services']: config['deactivated_services'].append(Console.name) hydrachain_app = start_app(config, accounts=[account]) all_apps.append(hydrachain_app) hydrachain_wait(private_keys, len(hydrachain_private_keys) - 1) return all_apps
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