def do_open_channel(self, funding_tx, conn_str, password): # read funding_sat from tx; converts '!' to int value funding_sat = funding_tx.output_value_for_address(ln_dummy_address()) lnworker = self.app.wallet.lnworker try: chan, funding_tx = lnworker.open_channel(connect_str=conn_str, funding_tx=funding_tx, funding_sat=funding_sat, push_amt_sat=0, password=password) except Exception as e: self.app.logger.exception("Problem opening channel") self.app.show_error( _('Problem opening channel: ') + '\n' + repr(e)) return # TODO: it would be nice to show this before broadcasting if chan.has_onchain_backup(): self.maybe_show_funding_tx(chan, funding_tx) else: title = _('Save backup') help_text = _(messages.MSG_CREATED_NON_RECOVERABLE_CHANNEL) data = lnworker.export_channel_backup(chan.channel_id) popup = QRDialog( title, data, show_text=False, text_for_clipboard=data, help_text=help_text, close_button_text=_('OK'), on_close=lambda: self.maybe_show_funding_tx(chan, funding_tx)) popup.open()
class PasswordDialog(AbstractPasswordDialog): enter_pw_message = _('Enter your password') enter_new_pw_message = _('Enter new password') confirm_new_pw_message = _('Confirm new password') wrong_password_message = _('Wrong password') allow_disable = False def __init__(self, app, **kwargs): AbstractPasswordDialog.__init__(self, app, **kwargs) self.hide_wallet_label = app._use_single_password def clear_password(self): self.ids.textinput_generic_password.text = '' def on_password(self, pw: str): # if not self.require_password: self.success = True self.message = _('Please wait...') self.dismiss() return # if setting new generic password, enforce min length if self.level > 0: if len(pw) < 6: self.app.show_error( _('Password is too short (min {} characters)').format(6)) return # don't enforce minimum length on existing self.do_check(pw)
def init_storage_from_path(self, path): self.storage = WalletStorage(path) self.basename = self.storage.basename() if not self.storage.file_exists(): self.require_password = False self.message = _('Press Next to create') elif self.storage.is_encrypted(): if not self.storage.is_encrypted_with_user_pw(): raise Exception( "Kivy GUI does not support this type of encrypted wallet files." ) self.pw_check = self.storage.check_password if self.app.password and self.check_password(self.app.password): self.pw = self.app.password # must be set so that it is returned in callback self.require_password = False self.message = _('Press Next to open') else: self.require_password = True self.message = self.enter_pw_message else: # it is a bit wasteful load the wallet here and load it again in main_window, # but that is fine, because we are progressively enforcing storage encryption. db = WalletDB(self.storage.read(), manual_upgrades=False) wallet = Wallet(db, self.storage, config=self.app.electrum_config) self.require_password = wallet.has_password() self.pw_check = wallet.check_password self.message = self.enter_pw_message if self.require_password else _( 'Wallet not encrypted')
def _confirm_force_close(self): Question( _('Confirm force close?'), self._do_force_close, title=_('Force-close channel'), no_str=_('Cancel'), yes_str=_('Proceed')).open()
def open_channel(self): if not self.pubkey or not self.amount: self.app.show_info(_('All fields must be filled out')) return if self.use_gossip: conn_str = self.pubkey if self.ipport: conn_str += '@' + self.ipport.strip() else: conn_str = str(self.trampolines[self.pubkey]) amount = '!' if self.is_max else self.app.get_amount(self.amount) self.dismiss() lnworker = self.app.wallet.lnworker try: node_id, rest = extract_nodeid(conn_str) except ConnStringFormatError as e: self.app.show_error(_('Problem opening channel: ') + '\n' + str(e)) return if lnworker.has_conflicting_backup_with(node_id): msg = messages.MGS_CONFLICTING_BACKUP_INSTANCE d = Question(msg, lambda x: self._open_channel(x, conn_str, amount)) d.open() else: self._open_channel(True, conn_str, amount)
def close(self): dialog = ChoiceDialog( title=_('Close channel'), choices={0:_('Cooperative close'), 1:_('Request force-close')}, key=0, callback=self._close, description=_(messages.MSG_REQUEST_FORCE_CLOSE), keep_choice_order=True) dialog.open()
def export_backup(self): text = self.app.wallet.lnworker.export_channel_backup(self.chan.channel_id) # TODO: some messages are duplicated between Kivy and Qt. help_text = ' '.join([ _("Channel backups can be imported in another instance of the same wallet, by scanning this QR code."), _("Please note that channel backups cannot be used to restore your channels."), _("If you lose your wallet file, the only thing you can do with a backup is to request your channel to be closed, so that your funds will be sent on-chain."), ]) self.app.qr_dialog(_("Channel Backup " + self.chan.short_id_for_GUI()), text, help_text=help_text)
def __init__(self, msg, callback, *, yes_str: str = None, no_str: str = None, title: str = None): Factory.Popup.__init__(self) self.yes_str = yes_str or _('Yes') self.no_str = no_str or _('No') self.title = title or _('Question') self.message = msg self.callback = callback
def update(self): self.menu_actions = [(_('Show'), self.do_show), (_('Delete'), self.do_delete)] requests_list = self.ids.requests_container requests_list.clear_widgets() _list = self.app.wallet.get_sorted_requests(self.app.electrum_config) for pr in _list: ci = self.get_card(pr) requests_list.add_widget(ci)
def get_card(self, addr, balance, is_used, label): ci = {} ci['screen'] = self ci['address'] = addr ci['memo'] = label ci['amount'] = self.app.format_amount_and_units(balance) ci['status'] = _('Used') if is_used else _( 'Funded') if balance > 0 else _('Unused') ci['is_frozen'] = self.app.wallet.is_frozen_address(addr) return ci
def _request_force_close(self, b): if not b: return loop = self.app.wallet.network.asyncio_loop coro = asyncio.run_coroutine_threadsafe(self.app.wallet.lnworker.request_force_close(self.chan.channel_id), loop) try: coro.result(5) self.app.show_info(_('Request sent')) except Exception as e: self.logger.exception("Could not close channel") self.app.show_info(_('Could not close channel: ') + repr(e)) # repr because str(Exception()) == ''
def _do_force_close(self, b): if not b: return loop = self.app.wallet.network.asyncio_loop coro = asyncio.run_coroutine_threadsafe(self.app.wallet.lnworker.force_close_channel(self.chan.channel_id), loop) try: coro.result(1) self.app.show_info(_('Channel closed, you may need to wait at least {} blocks, because of CSV delays'.format(self.chan.config[REMOTE].to_self_delay))) except Exception as e: self.logger.exception("Could not force close channel") self.app.show_info(_('Could not force close channel: ') + repr(e)) # repr because str(Exception()) == ''
def update_status(self): invoice = self.app.wallet.get_invoice(self.key) self.status = self.app.wallet.get_invoice_status(invoice) self.status_str = invoice.get_status_str(self.status) self.status_color = pr_color[self.status] self.can_pay = self.status in [PR_UNPAID, PR_FAILED] if self.can_pay and self.is_lightning and self.app.wallet.lnworker: if self.amount_sat and self.amount_sat > self.app.wallet.lnworker.num_sats_can_send( ): self.warning = _('Warning') + ': ' + _( 'This amount exceeds the maximum you can currently send with your channels' )
def routing_dialog(self, item, dt): description = _(messages.MSG_HELP_TRAMPOLINE) def cb(text): self.app.use_gossip = (text == 'Gossip') dialog = ChoiceDialog( _('Lightning Routing'), ['Trampoline', 'Gossip'], 'Gossip' if self.app.use_gossip else 'Trampoline', cb, description=description, keep_choice_order=True) dialog.open()
def do_pay_invoice(self, invoice): if invoice.is_lightning(): if self.app.wallet.lnworker: amount_sat = invoice.get_amount_sat() msg = _("Pay lightning invoice?") + '\n\n' + _( "This will send {}?").format( self.app.format_amount_and_units_with_fiat( amount_sat)) + '\n' self.app.protected(msg, self._do_pay_lightning, (invoice, )) else: self.app.show_error( _("Lightning payments are not available for this wallet")) else: self._do_pay_onchain(invoice)
def maybe_show_funding_tx(self, chan, funding_tx): n = chan.constraints.funding_txn_minimum_depth message = '\n'.join([ _('Channel established.'), _('Remote peer ID') + ':' + chan.node_id.hex(), _('This channel will be usable after {} confirmations').format(n) ]) if not funding_tx.is_complete(): message += '\n\n' + _( 'Please sign and broadcast the funding transaction') self.app.show_info(message) if not funding_tx.is_complete(): self.app.tx_dialog(funding_tx)
def _close(self, choice): loop = self.app.wallet.network.asyncio_loop if choice == 1: coro = self.app.wallet.lnworker.request_force_close(self.chan.channel_id) msg = _('Request sent') else: coro = self.app.wallet.lnworker.close_channel(self.chan.channel_id) msg = _('Channel closed') f = asyncio.run_coroutine_threadsafe(coro, loop) try: f.result(5) self.app.show_info(msg) except Exception as e: self.logger.exception("Could not close channel") self.app.show_info(_('Could not close channel: ') + repr(e)) # repr because str(Exception()) == ''
def on_password(self, pw: str): # if not self.require_password: self.success = True self.message = _('Please wait...') self.dismiss() return # if setting new generic password, enforce min length if self.level > 0: if len(pw) < 6: self.app.show_error( _('Password is too short (min {} characters)').format(6)) return # don't enforce minimum length on existing self.do_check(pw)
def get_card(self, item: Invoice) -> Dict[str, Any]: status = self.app.wallet.get_invoice_status(item) status_str = item.get_status_str(status) is_lightning = item.type == PR_TYPE_LN key = self.app.wallet.get_key_for_outgoing_invoice(item) if is_lightning: assert isinstance(item, LNInvoice) address = item.rhash if self.app.wallet.lnworker: log = self.app.wallet.lnworker.logs.get(key) if status == PR_INFLIGHT and log: status_str += '... (%d)' % len(log) is_bip70 = False else: assert isinstance(item, OnchainInvoice) address = item.get_address() is_bip70 = bool(item.bip70) return { 'is_lightning': is_lightning, 'is_bip70': is_bip70, 'screen': self, 'status': status, 'status_str': status_str, 'key': key, 'memo': item.message or _('No Description'), 'address': address, 'amount': self.app.format_amount_and_units(item.get_amount_sat() or 0), }
def ipport_dialog(self): def callback(text): self.ipport = text d = LabelDialog(_('IP/port in format:\n[host]:[port]'), self.ipport, callback) d.open()
def update_status(self): req = self.app.wallet.get_request(self.key) self.status = self.app.wallet.get_request_status(self.key) self.status_str = req.get_status_str(self.status) self.status_color = pr_color[self.status] if self.status == PR_UNPAID and self.is_lightning and self.app.wallet.lnworker: if self.amount_sat and self.amount_sat > self.app.wallet.lnworker.num_sats_can_receive( ): self.warning = _('Warning') + ': ' + _( 'This amount exceeds the maximum you can currently receive with your channels' ) if self.status == PR_UNPAID and not self.is_lightning: address = req.get_address() if self.app.wallet.is_used(address): self.warning = _('Warning') + ': ' + _( 'This address is being reused')
def __init__(self, chan: Channel, app: 'ElectrumWindow', **kwargs): Popup.__init__(self, **kwargs) Logger.__init__(self) self.is_closed = chan.is_closed() self.can_be_deleted = chan.can_be_deleted() self.app = app self.chan = chan self.title = _('Channel details') self.node_id = bh2u(chan.node_id) self.channel_id = bh2u(chan.channel_id) self.funding_txid = chan.funding_outpoint.txid self.short_id = format_short_channel_id(chan.short_channel_id) self.capacity = self.app.format_amount_and_units(chan.get_capacity()) self.state = chan.get_state_for_GUI() self.local_ctn = chan.get_latest_ctn(LOCAL) self.remote_ctn = chan.get_latest_ctn(REMOTE) self.local_csv = chan.config[LOCAL].to_self_delay self.remote_csv = chan.config[REMOTE].to_self_delay self.initiator = 'Local' if chan.constraints.is_initiator else 'Remote' feerate_kw = chan.get_latest_feerate(LOCAL) self.feerate = str(quantize_feerate(Transaction.satperbyte_from_satperkw(feerate_kw))) self.can_send = self.app.format_amount_and_units(chan.available_to_spend(LOCAL) // 1000) self.can_receive = self.app.format_amount_and_units(chan.available_to_spend(REMOTE) // 1000) self.is_open = chan.is_open() closed = chan.get_closing_height() if closed: self.closing_txid, closing_height, closing_timestamp = closed msg = messages.MSG_NON_TRAMPOLINE_CHANNEL_FROZEN_WITHOUT_GOSSIP self.warning = '' if self.app.wallet.lnworker.channel_db or self.app.wallet.lnworker.is_trampoline_peer(chan.node_id) else _('Warning') + ': ' + msg self.is_frozen_for_sending = chan.is_frozen_for_sending() self.is_frozen_for_receiving = chan.is_frozen_for_receiving() self.update_action_dropdown()
def show_log(self): if self.log: log_str = _('Payment log:') + '\n\n' for payment_attempt_log in self.log: route_str, chan_str, message = payment_attempt_log.formatted_tuple( ) log_str += chan_str + ' --- ' + message + '\n' self.app.show_info(log_str)
def send_report(self): try: loop = self.main_window.network.asyncio_loop proxy = self.main_window.network.proxy # FIXME network request in GUI thread... response = json.loads(BaseCrashReporter.send_report(self, loop, proxy, "/crash.json", timeout=10)) except (ValueError, ClientError) as e: self.logger.warning(f"Error sending crash report. exc={e!r}") self.show_popup(_('Unable to send report'), _("Please check your network connection.")) else: self.show_popup(_('Report sent'), response["text"]) location = response["location"] if location: self.logger.info(f"Crash report sent. location={location!r}") self.open_url(location) self.dismiss()
def fx_status(self): fx = self.app.fx if fx.is_enabled(): source = fx.exchange.name() ccy = fx.get_currency() return '%s [%s]' % (ccy, source) else: return _('None')
class PincodeDialog(AbstractPasswordDialog): enter_pw_message = _('Enter your PIN') enter_new_pw_message = _('Enter new PIN') confirm_new_pw_message = _('Confirm new PIN') wrong_password_message = _('Wrong PIN') allow_disable = True def __init__(self, app, **kwargs): AbstractPasswordDialog.__init__(self, app, **kwargs) def clear_password(self): self.ids.kb.password = '' def on_password(self, pw: str): # PIN codes are exactly 6 chars if len(pw) >= 6: self.do_check(pw)
def do_delete(self, obj): from .question import Question def cb(result): if result: self.app.wallet.invoices.remove(obj.key) self.hide_menu() self.update() d = Question(_('Delete invoice?'), cb) d.open()
def expiration_dialog(self, obj): from .dialogs.choice_dialog import ChoiceDialog def callback(c): self.app.electrum_config.set_key('request_expiry', c) d = ChoiceDialog(_('Expiration date'), pr_expiration_values, self.expiry(), callback) d.open()
def remove_local_tx(self): txid = self.tx.txid() num_child_txs = len(self.wallet.get_depending_transactions(txid)) question = _("Are you sure you want to remove this transaction?") if num_child_txs > 0: question = (_( "Are you sure you want to remove this transaction and {} child transactions?" ).format(num_child_txs)) def on_prompt(b): if b: self.wallet.remove_transaction(txid) self.wallet.save_db() self.app._trigger_update_wallet() # FIXME private... self.dismiss() d = Question(question, on_prompt) d.open()
def on_address(self, addr): req = self.app.wallet.get_request(addr) self.status = '' if req: self.message = req.get('memo', '') amount = req.get('amount') self.amount = self.app.format_amount_and_units( amount) if amount else '' status = req.get('status', PR_UNKNOWN) self.status = _('Payment received') if status == PR_PAID else ''