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 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.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 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.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 stop(self):
request = ln.StopRequest()
try:
response = self.lnd_client.StopDaemon(request)
except _Rendezvous:
log.error('stop lnd error', exc_info=True)
response = self.stop()
return response
def handle_output(self):
while self.process.canReadLine():
line_bytes: QByteArray = self.process.readLine()
try:
line_str = line_bytes.data().decode('utf-8').strip()
except UnicodeDecodeError:
log.error('handle_output decode error', exc_info=True)
continue
self.output.append(line_str)
self.process_output_line(line_str)
def handle_output(self):
while self.canReadLine():
line_bytes: QByteArray = self.readLine()
try:
line_str = line_bytes.data().decode('utf-8').strip()
except UnicodeDecodeError:
log.error('handle_output decode error', exc_info=True)
continue
log.debug(f'Process output', line=line_str, binary=self.binary)
self.process_output_line(line_str)
self.log_line.emit(line_str)
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)
def create_wallet(self):
new_wallet_password = self.get_new_password(
title=f'Create {self.node_set.bitcoin.network} LND Wallet',
password_name='LND Wallet')
keyring_service_name = f'lnd_{self.node_set.bitcoin.network}_wallet_password'
keyring_user_name = str(time.time())
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)
new_seed_password = self.get_new_password(
title=f'Create {self.node_set.bitcoin.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:
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.bitcoin.network}_wallet_password',
username=self.node_set.bitcoin.file['rpcuser'],
password=new_wallet_password)