def make_address_electrum(mnemonic: str,
second: str,
num: int = 0,
script: str = 'p2wpkh',
path: str = 'wallet.db',
remove: bool = True):
if electrum is None:
raise ImportError(
'Unable to import electrum. Follow README instructions.')
if len(second) < MIN_LEN_PASSWORD:
raise ValueError(
f'Password too short {len(second)} < {MIN_LEN_PASSWORD}')
script_types = ('p2pkh', 'p2wpkh', 'p2wpkh-p2sh')
if script not in script_types:
raise ValueError(f'Script {script} must be noe of {script_types}')
if os.path.exists(path):
os.unlink(path)
language = 'english'
seed = Mnemonic(language).to_seed(mnemonic).hex()
derivation = None
if script == 'p2wpkh':
derivation = "m/84'/0'/0'"
elif script == 'p2wpkh-p2sh':
derivation = "m/49'/0'/0'"
elif script == 'p2pkh':
script = 'standard'
derivation = "m/44'/0'/0'"
ks = keystore.from_bip39_seed(mnemonic, second, derivation, xtype=script)
db = WalletDB('', manual_upgrades=False)
db.put('keystore', ks.dump())
db.put('wallet_type', 'standard')
storage = WalletStorage(path)
wallet = Wallet(db, storage, config=SimpleConfig())
if not storage.file_exists():
wallet.update_password(old_pw=None,
new_pw=second,
encrypt_storage=True)
wallet.synchronize()
wallet.save_db()
addr = wallet.get_receiving_addresses()[num]
wif = wallet.export_private_key(addr, password=second)
if remove:
os.unlink(path)
return AddressResult(address=addr, wif=wif, num=num)
def test_write_dictionary_to_file(self):
storage = WalletStorage(self.wallet_path)
db = WalletDB('', manual_upgrades=True)
some_dict = {
u"a": u"b",
u"c": u"d",
u"seed_version": FINAL_SEED_VERSION}
for key, value in some_dict.items():
db.put(key, value)
db.write(storage)
with open(self.wallet_path, "r") as f:
contents = f.read()
d = json.loads(contents)
for key, value in some_dict.items():
self.assertEqual(d[key], value)
def create_storage(self, js_data, single_password_enabled,
single_password):
self._logger.info('Creating wallet from wizard data')
data = js_data.toVariant()
self._logger.debug(str(data))
if single_password_enabled and single_password:
data['encrypt'] = True
data['password'] = single_password
try:
path = os.path.join(
os.path.dirname(self.daemon.config.get_wallet_path()),
data['wallet_name'])
if os.path.exists(path):
raise Exception('file already exists at path')
storage = WalletStorage(path)
if data['seed_type'] in ['old', 'standard',
'segwit']: #2fa, 2fa-segwit
self._logger.debug('creating keystore from electrum seed')
k = keystore.from_seed(data['seed'], data['seed_extra_words'],
data['wallet_type'] == 'multisig')
elif data['seed_type'] == 'bip39':
self._logger.debug('creating keystore from bip39 seed')
root_seed = keystore.bip39_to_seed(data['seed'],
data['seed_extra_words'])
derivation = normalize_bip32_derivation(
data['derivation_path'])
script = data['script_type'] if data[
'script_type'] != 'p2pkh' else 'standard'
k = keystore.from_bip43_rootseed(root_seed,
derivation,
xtype=script)
else:
raise Exception('unsupported/unknown seed_type %s' %
data['seed_type'])
if data['encrypt']:
if k.may_have_password():
k.update_password(None, data['password'])
storage.set_password(
data['password'],
enc_version=StorageEncryptionVersion.USER_PASSWORD)
db = WalletDB('', manual_upgrades=False)
db.set_keystore_encryption(
bool(data['password']) and data['encrypt'])
db.put('wallet_type', data['wallet_type'])
db.put('seed_type', data['seed_type'])
db.put('keystore', k.dump())
if k.can_have_deterministic_lightning_xprv():
db.put(
'lightning_xprv',
k.get_lightning_xprv(
data['password'] if data['encrypt'] else None))
db.load_plugins()
db.write(storage)
# minimally populate self after create
self._password = data['password']
self.path = path
self.createSuccess.emit()
except Exception as e:
self._logger.error(str(e))
self.createError.emit(str(e))
