def generate_seed(self, new_seed_password: str):
try:
generate_seed_response = self.node_set.lnd_client.generate_seed(
seed_password=new_seed_password)
except _Rendezvous as e:
log.error('generate_seed', exc_info=True)
# noinspection PyProtectedMember
self.error_message.showMessage(e._state.details)
return
seed = generate_seed_response.cipher_seed_mnemonic
keyring_service_name = f'lnd_seed'
keyring_user_name = ''.join(seed[0:2])
log.info('generate_seed',
keyring_service_name=keyring_service_name,
keyring_user_name=keyring_user_name)
keyring.set_password(service=keyring_service_name,
username=keyring_user_name,
password='******'.join(seed))
keyring.set_password(service=f'{keyring_service_name}_seed_password',
username=keyring_user_name,
password=new_seed_password)
return seed
def generate_seed(self, new_seed_password: str):
try:
generate_seed_response = self.client.generate_seed(
seed_password=new_seed_password
)
except _Rendezvous:
log.error('generate_seed error', exc_info=True)
raise
seed = generate_seed_response.cipher_seed_mnemonic
keyring_service_name = f'lnd_seed'
keyring_user_name = ''.join(seed[0:2])
log.info(
'generate_seed',
keyring_service_name=keyring_service_name,
keyring_user_name=keyring_user_name
)
keyring.set_password(
service=keyring_service_name,
username=keyring_user_name,
password='******'.join(seed)
)
keyring.set_password(
service=f'{keyring_service_name}_seed_password',
username=keyring_user_name,
password=new_seed_password
)
return seed
def handle_unlock_wallet(self, details: str):
if details is None:
return
details = details.lower()
# The Wallet Unlocker gRPC service disappears from LND's API
# after the wallet is unlocked (or created/recovered)
if 'unknown service lnrpc.walletunlocker' in details:
pass
# User needs to create a new wallet
elif 'wallet not found' in details:
new_wallet_password = get_random_password()
keyring_service_name = keyring_user_name = f'lnd_wallet_password'
log.info('create_wallet',
keyring_service_name=keyring_service_name,
keyring_user_name=keyring_user_name)
keyring.set_password(service=keyring_service_name,
username=keyring_user_name,
password=new_wallet_password)
seed = self.generate_seed(new_wallet_password)
try:
self.node_set.lnd_client.initialize_wallet(
wallet_password=new_wallet_password,
seed=seed,
seed_password=new_wallet_password)
except _Rendezvous as e:
log.error('initialize_wallet', exc_info=True)
# noinspection PyProtectedMember
self.error_message.showMessage(e._state.details)
return
keyring.set_password(
service=f'lnd_{self.node_set.litecoin.network}_wallet_password',
username=self.node_set.litecoin.file['rpcuser'],
password=new_wallet_password)
else:
log.warning('unlock_wallet failed', details=details, exc_info=True)
def unlock_wallet(self):
password = self.password_prompt(
title=f'Unlock {self.node_set.bitcoin.network} LND Wallet',
label='Wallet Password')
try:
self.node_set.lnd_client.unlock(wallet_password=password)
except _Rendezvous as e:
log.error('unlock_wallet', exc_info=True)
# noinspection PyProtectedMember
self.error_message.showMessage(e._state.details)
return
timestamp = str(time.time())
keyring_service_name = f'lnd_{self.node_set.bitcoin.network}_wallet_password'
log.info('unlock_wallet',
keyring_service_name=keyring_service_name,
keyring_user_name=timestamp)
keyring.set_password(service=keyring_service_name,
username=timestamp,
password=password)
keyring.set_password(service=keyring_service_name,
username=self.node_set.bitcoin.file['rpcuser'],
password=password)
def handle_unlock_wallet(self, details: str):
if details is None:
return
details = details.lower()
# The Wallet Unlocker gRPC service disappears from LND's API
# after the wallet is unlocked (or created/recovered)
if 'unknown service lnrpc.walletunlocker' in details:
pass
# User needs to create a new wallet
elif 'wallet not found' in details:
new_wallet_password = get_random_password()
keyring_service_name = keyring_user_name = f'lnd_wallet_password'
log.info('create_wallet',
keyring_service_name=keyring_service_name,
keyring_user_name=keyring_user_name)
keyring.set_password(service=keyring_service_name,
username=keyring_user_name,
password=new_wallet_password)
seed = self.generate_seed(new_wallet_password)
try:
self.lnd.client.initialize_wallet(
wallet_password=new_wallet_password,
seed=seed,
seed_password=new_wallet_password)
except _Rendezvous:
log.error('initialize_wallet error', exc_info=True)
raise
keyring.set_password(service=f'lnd_mainnet_wallet_password',
username=self.lnd.file['bitcoind.rpcuser'],
password=new_wallet_password)
else:
log.warning('unlock_wallet failed', details=details, exc_info=True)
def create_wallet(self):
new_wallet_password = self.get_new_password(
title=f'Create {self.node_set.network} LND Wallet',
password_name='LND Wallet')
keyring.set_password(
service=f'lnd_{self.node_set.network}_wallet_password',
username=str(time.time()),
password=new_wallet_password)
new_seed_password = self.get_new_password(
title=f'Create {self.node_set.network} LND Wallet',
password_name='Mnemonic Seed')
seed = self.generate_seed(new_seed_password)
self.backup_seed(seed)
try:
self.node_set.lnd_client.initialize_wallet(
wallet_password=new_wallet_password,
seed=seed,
seed_password=new_seed_password)
except _Rendezvous as e:
# noinspection PyProtectedMember
self.error_message.showMessage(e._state.details)
return
keyring.set_password(
service=f'lnd_{self.node_set.network}_wallet_password',
username=self.node_set.bitcoin.file['rpcuser'],
password=new_wallet_password)
def test_keyring(self):
timestamp = str(time.time())
keyring.set_password(service='test_entry',
username=timestamp,
password='******')
password = keyring.get_password(service='test_entry',
username=timestamp)
assert password == 'test_password'
keyring.delete_password(service='test_entry', username=timestamp)
def unlock_wallet(self):
password, ok = QInputDialog.getText(self.password_dialog,
f'Unlock {self.node_set.network} LND Wallet',
'Wallet Password',
QLineEdit.Password)
if not ok:
return
try:
self.node_set.lnd_client.unlock(wallet_password=password)
keyring.set_password(
service=f'lnd_{self.node_set.network}_wallet_password',
username=str(time.time()),
password=password)
except _Rendezvous as e:
# noinspection PyProtectedMember
self.error_message.showMessage(e._state.details)
return
def create_wallet(self):
try:
new_wallet_password, ok = QInputDialog.getText(
self.password_dialog,
f'Create {self.node_set.network} LND Wallet',
'New Wallet Password', QLineEdit.Password)
if not ok:
return
seed_password, ok = QInputDialog.getText(
self.password_dialog,
f'Create {self.node_set.network} LND Wallet',
'New Seed Password (Optional)', QLineEdit.Password)
if not ok:
return
if not seed_password:
seed_password = None
generate_seed_response = self.node_set.lnd_client.generate_seed(
seed_password=seed_password)
seed = generate_seed_response.cipher_seed_mnemonic
seed_text = ''.join([
f'{index + 1}: {value}\n' for index, value in enumerate(seed)
])
seed_dialog = SeedDialog()
seed_dialog.text.setText(seed_text)
seed_dialog.show()
timestamp = str(time.time())
keyring.set_password(
service=f'lnd_{self.node_set.network}_wallet_password',
username=timestamp,
password=new_wallet_password)
keyring.set_password(service=f'lnd_{self.node_set.network}_seed',
username=timestamp,
password=seed_text)
if seed_password is not None:
keyring.set_password(
service=f'lnd_{self.node_set.network}_seed_password',
username=timestamp,
password=seed_password)
self.node_set.lnd_client.initialize_wallet(
wallet_password=new_wallet_password,
seed=seed,
seed_password=seed_password)
except _Rendezvous as e:
# noinspection PyProtectedMember
self.error_message.showMessage(e._state.details)
return
keyring.set_password(
service=f'lnd_{self.node_set.network}_wallet_password',
username=self.node_set.bitcoin.file['rpcuser'],
password=new_wallet_password)
def recover_wallet(self):
try:
new_wallet_password, ok = QInputDialog.getText(
self.password_dialog,
f'Recover {self.node_set.network} LND Wallet',
'New Wallet Password', QLineEdit.Password)
if not ok:
return
seed_password, ok = QInputDialog.getText(
self.password_dialog,
f'Recover {self.node_set.network} LND Wallet',
'Seed Password (Optional)', QLineEdit.Password)
if not ok:
return
if not seed_password:
seed_password = None
seed, ok = QInputDialog.getText(
self.password_dialog,
f'Recover {self.node_set.network} LND Wallet', 'Seed')
if not ok:
return
seed_list = seed.split(' ')
timestamp = str(time.time())
keyring.set_password(
service=f'lnd_{self.node_set.network}_wallet_password',
username=timestamp,
password=new_wallet_password)
keyring.set_password(service=f'lnd_{self.node_set.network}_seed',
username=timestamp,
password=seed)
if seed_password is not None:
keyring.set_password(
service=f'lnd_{self.node_set.network}_seed_password',
username=timestamp,
password=seed_password)
self.node_set.lnd_client.initialize_wallet(
wallet_password=new_wallet_password,
seed=seed_list,
seed_password=seed_password,
recovery_window=10000)
except _Rendezvous as e:
# noinspection PyProtectedMember
self.error_message.showMessage(e._state.details)
return
keyring.set_password(
service=f'lnd_{self.node_set.network}_wallet_password',
username=self.node_set.bitcoin.file['rpcuser'],
password=new_wallet_password)
def generate_seed(self, new_seed_password: str):
try:
generate_seed_response = self.node_set.lnd_client.generate_seed(
seed_password=new_seed_password)
except _Rendezvous as e:
# noinspection PyProtectedMember
self.error_message.showMessage(e._state.details)
return
seed = generate_seed_response.cipher_seed_mnemonic
keyring.set_password(service=f'lnd_{self.node_set.network}_seed',
username=''.join(seed[0:2]),
password='******'.join(seed))
if new_seed_password is not None:
keyring.set_password(
service=f'lnd_{self.node_set.network}_seed_password',
username=''.join(seed[0:2]),
password=new_seed_password)
return seed
def recover_wallet(self):
title = f'Recover {self.node_set.bitcoin.network} LND Wallet'
new_wallet_password = self.get_new_password(title=title,
password_name='LND Wallet')
seed_password = self.password_prompt(title=title,
label='Seed Password (Optional)')
seed, ok = QInputDialog.getText(
self.password_dialog, title,
'Mnemonic Seed (one line with spaces)')
if not ok:
raise Exception()
seed_list = seed.split(' ')
keyring_service_name = f'lnd_{self.node_set.bitcoin.network}'
keyring_user_name = str(time.time())
log.info('recover_wallet',
keyring_service_name=keyring_service_name,
keyring_user_name=keyring_user_name)
keyring.set_password(service=f'{keyring_service_name}_wallet_password',
username=keyring_user_name,
password=new_wallet_password)
keyring.set_password(service=f'{keyring_service_name}_seed',
username=keyring_user_name,
password=seed)
if seed_password is not None:
keyring.set_password(
service=f'{keyring_service_name}_seed_password',
username=keyring_user_name,
password=seed_password)
try:
self.node_set.lnd_client.initialize_wallet(
wallet_password=new_wallet_password,
seed=seed_list,
seed_password=seed_password,
recovery_window=10000)
except _Rendezvous as e:
log.error('recover_wallet_initialize_wallet', exc_info=True)
# noinspection PyProtectedMember
self.error_message.showMessage(e._state.details)
return
keyring.set_password(
service=f'lnd_{self.node_set.bitcoin.network}_wallet_password',
username=self.node_set.bitcoin.file['rpcuser'],
password=new_wallet_password)
