X-Git-Url: https://git.novaco.in/?a=blobdiff_plain;f=gui%2Fqt%2Fmain_window.py;h=874b8e28c3956402c7dd3710e2a02f0a340b2990;hb=81d1e67253c8ca581e821a6cd9e5ee1502fffd08;hp=dae8c32c6d9de0ef2ed55ebb1b4d36c21bdf5780;hpb=513f9c2d89e9a530710bb163ea713f6948185fbc;p=electrum-nvc.git diff --git a/gui/qt/main_window.py b/gui/qt/main_window.py index dae8c32..874b8e2 100644 --- a/gui/qt/main_window.py +++ b/gui/qt/main_window.py @@ -35,18 +35,17 @@ from electrum.plugins import run_hook import icons_rc -from electrum.wallet import format_satoshis +from electrum.util import format_satoshis from electrum import Transaction from electrum import mnemonic from electrum import util, bitcoin, commands, Interface, Wallet from electrum import SimpleConfig, Wallet, WalletStorage +from electrum import Imported_Wallet - -from electrum import bmp, pyqrnative - -from amountedit import AmountEdit, MyLineEdit +from amountedit import AmountEdit, BTCAmountEdit, MyLineEdit from network_dialog import NetworkDialog -from qrcodewidget import QRCodeWidget +from qrcodewidget import QRCodeWidget, QRDialog +from qrtextedit import QRTextEdit from decimal import Decimal @@ -63,14 +62,29 @@ elif platform.system() == 'Darwin': else: MONOSPACE_FONT = 'monospace' -from electrum import ELECTRUM_VERSION -import re -from util import * +# status of payment requests +PR_UNPAID = 0 +PR_EXPIRED = 1 +PR_SENT = 2 # sent but not propagated +PR_PAID = 3 # send and propagated +PR_ERROR = 4 # could not parse +from electrum import ELECTRUM_VERSION +import re +from util import MyTreeWidget, HelpButton, EnterButton, line_dialog, text_dialog, ok_cancel_buttons, close_button, WaitingDialog + + +def format_status(x): + if x == PR_UNPAID: + return _('Unpaid') + elif x == PR_PAID: + return _('Paid') + elif x == PR_EXPIRED: + return _('Expired') class StatusBarButton(QPushButton): @@ -117,10 +131,10 @@ class ElectrumWindow(QMainWindow): self.decimal_point = config.get('decimal_point', 5) self.num_zeros = int(config.get('num_zeros',0)) + self.invoices = {} set_language(config.get('language')) - self.funds_error = False self.completions = QStringListModel() self.tabs = tabs = QTabWidget(self) @@ -128,6 +142,7 @@ class ElectrumWindow(QMainWindow): tabs.addTab(self.create_history_tab(), _('History') ) tabs.addTab(self.create_send_tab(), _('Send') ) tabs.addTab(self.create_receive_tab(), _('Receive') ) + tabs.addTab(self.create_addresses_tab(), _('Addresses') ) tabs.addTab(self.create_contacts_tab(), _('Contacts') ) tabs.addTab(self.create_invoices_tab(), _('Invoices') ) tabs.addTab(self.create_console_tab(), _('Console') ) @@ -172,7 +187,7 @@ class ElectrumWindow(QMainWindow): self.console.showMessage(self.network.banner) self.wallet = None - + self.payment_request = None def update_account_selector(self): # account selector @@ -192,6 +207,7 @@ class ElectrumWindow(QMainWindow): self.wallet = wallet self.update_wallet_format() + self.invoices = self.wallet.storage.get('invoices', {}) self.accounts_expanded = self.wallet.storage.get('accounts_expanded',{}) self.current_account = self.wallet.storage.get("current_account", None) title = 'Electrum ' + self.wallet.electrum_version + ' - ' + self.wallet.storage.path @@ -213,6 +229,8 @@ class ElectrumWindow(QMainWindow): self.update_buttons_on_seed() self.update_console() + self.clear_receive_tab() + self.update_receive_tab() run_hook('load_wallet', wallet) @@ -268,12 +286,20 @@ class ElectrumWindow(QMainWindow): import installwizard wallet_folder = os.path.dirname(self.wallet.storage.path) - filename = unicode( QFileDialog.getSaveFileName(self, _('Enter a new file name'), wallet_folder) ) + i = 1 + while True: + filename = "wallet_%d"%i + if filename in os.listdir(wallet_folder): + i += 1 + else: + break + + filename = line_dialog(self, _('New Wallet'), _('Enter file name') + ':', _('OK'), filename) if not filename: return - filename = os.path.join(wallet_folder, filename) - storage = WalletStorage({'wallet_path': filename}) + full_path = os.path.join(wallet_folder, filename) + storage = WalletStorage({'wallet_path': full_path}) if storage.file_exists: QMessageBox.critical(None, "Error", _("File exists")) return @@ -323,7 +349,7 @@ class ElectrumWindow(QMainWindow): tools_menu.addAction(_("&Plugins"), self.plugins_dialog) tools_menu.addSeparator() tools_menu.addAction(_("&Sign/verify message"), self.sign_verify_message) - #tools_menu.addAction(_("&Encrypt/decrypt message"), self.encrypt_message) + tools_menu.addAction(_("&Encrypt/decrypt message"), self.encrypt_message) tools_menu.addSeparator() csv_transaction_menu = tools_menu.addMenu(_("&Create transaction")) @@ -334,6 +360,8 @@ class ElectrumWindow(QMainWindow): raw_transaction_menu.addAction(_("&From file"), self.do_process_from_file) raw_transaction_menu.addAction(_("&From text"), self.do_process_from_text) raw_transaction_menu.addAction(_("&From the blockchain"), self.do_process_from_txid) + raw_transaction_menu.addAction(_("&From QR code"), self.read_tx_from_qrcode) + self.raw_transaction_menu = raw_transaction_menu help_menu = menubar.addMenu(_("&Help")) help_menu.addAction(_("&About"), self.show_about) @@ -413,6 +441,7 @@ class ElectrumWindow(QMainWindow): if self.need_update.is_set(): self.update_wallet() self.need_update.clear() + run_hook('timer_actions') def format_amount(self, x, is_diff=False, whitespaces=False): @@ -424,9 +453,14 @@ class ElectrumWindow(QMainWindow): def base_unit(self): - assert self.decimal_point in [5,8] - return "BTC" if self.decimal_point == 8 else "mBTC" - + assert self.decimal_point in [2, 5, 8] + if self.decimal_point == 2: + return 'bits' + if self.decimal_point == 5: + return 'mBTC' + if self.decimal_point == 8: + return 'BTC' + raise Exception('Unknown base unit') def update_status(self): if self.network is None or not self.network.is_running(): @@ -467,6 +501,7 @@ class ElectrumWindow(QMainWindow): if self.wallet.up_to_date or not self.network or not self.network.is_connected(): self.update_history_tab() self.update_receive_tab() + self.update_address_tab() self.update_contacts_tab() self.update_completions() self.update_invoices_tab() @@ -478,9 +513,8 @@ class ElectrumWindow(QMainWindow): for i,width in enumerate(self.column_widths['history']): l.setColumnWidth(i, width) l.setHeaderLabels( [ '', _('Date'), _('Description') , _('Amount'), _('Balance')] ) - self.connect(l, SIGNAL('itemDoubleClicked(QTreeWidgetItem*, int)'), self.tx_label_clicked) - self.connect(l, SIGNAL('itemChanged(QTreeWidgetItem*, int)'), self.tx_label_changed) - + l.itemDoubleClicked.connect(self.tx_label_clicked) + l.itemChanged.connect(self.tx_label_changed) l.customContextMenuRequested.connect(self.create_history_menu) return l @@ -537,7 +571,7 @@ class ElectrumWindow(QMainWindow): def edit_label(self, is_recv): - l = self.receive_list if is_recv else self.contacts_list + l = self.address_list if is_recv else self.contacts_list item = l.currentItem() item.setFlags(Qt.ItemIsEditable|Qt.ItemIsSelectable | Qt.ItemIsUserCheckable | Qt.ItemIsEnabled | Qt.ItemIsDragEnabled) l.editItem( item, 1 ) @@ -636,18 +670,170 @@ class ElectrumWindow(QMainWindow): run_hook('history_tab_update') + def create_receive_tab(self): + w = QWidget() + grid = QGridLayout(w) + grid.setColumnMinimumWidth(3, 300) + grid.setColumnStretch(5, 1) + + self.receive_address_e = QLineEdit() + self.receive_address_e.setReadOnly(True) + grid.addWidget(QLabel(_('Receiving address')), 0, 0) + grid.addWidget(self.receive_address_e, 0, 1, 1, 3) + self.receive_address_e.textChanged.connect(self.update_receive_qr) + + self.receive_message_e = QLineEdit() + grid.addWidget(QLabel(_('Message')), 1, 0) + grid.addWidget(self.receive_message_e, 1, 1, 1, 3) + self.receive_message_e.textChanged.connect(self.update_receive_qr) + + self.receive_amount_e = BTCAmountEdit(self.get_decimal_point) + grid.addWidget(QLabel(_('Requested amount')), 2, 0) + grid.addWidget(self.receive_amount_e, 2, 1, 1, 2) + self.receive_amount_e.textChanged.connect(self.update_receive_qr) + + self.save_request_button = QPushButton(_('Save')) + self.save_request_button.clicked.connect(self.save_payment_request) + grid.addWidget(self.save_request_button, 3, 1) + clear_button = QPushButton(_('New')) + clear_button.clicked.connect(self.new_receive_address) + grid.addWidget(clear_button, 3, 2) + grid.setRowStretch(4, 1) + + self.receive_qr = QRCodeWidget(fixedSize=200) + grid.addWidget(self.receive_qr, 0, 4, 5, 2) + + grid.setRowStretch(5, 1) + + self.receive_requests_label = QLabel(_('Saved Requests')) + self.receive_list = MyTreeWidget(self) + self.receive_list.customContextMenuRequested.connect(self.receive_list_menu) + self.receive_list.currentItemChanged.connect(self.receive_item_changed) + self.receive_list.itemClicked.connect(self.receive_item_changed) + self.receive_list.setHeaderLabels( [_('Address'), _('Message'), _('Amount')] ) + self.receive_list.setColumnWidth(0, 340) + h = self.receive_list.header() + h.setStretchLastSection(False) + h.setResizeMode(1, QHeaderView.Stretch) + + grid.addWidget(self.receive_requests_label, 6, 0) + grid.addWidget(self.receive_list, 7, 0, 1, 6) + return w + + def receive_item_changed(self, item): + if item is None: + return + addr = str(item.text(0)) + amount, message = self.receive_requests[addr] + self.receive_address_e.setText(addr) + self.receive_message_e.setText(message) + self.receive_amount_e.setAmount(amount) + + + def receive_list_delete(self, item): + addr = str(item.text(0)) + self.receive_requests.pop(addr) + self.update_receive_tab() + self.clear_receive_tab() + + def receive_list_menu(self, position): + item = self.receive_list.itemAt(position) + menu = QMenu() + menu.addAction(_("Delete"), lambda: self.receive_list_delete(item)) + menu.exec_(self.receive_list.viewport().mapToGlobal(position)) + + def save_payment_request(self): + addr = str(self.receive_address_e.text()) + amount = self.receive_amount_e.get_amount() + message = str(self.receive_message_e.text()) + if not message and not amount: + QMessageBox.warning(self, _('Error'), _('No message or amount'), _('OK')) + return + self.receive_requests = self.wallet.storage.get('receive_requests',{}) + self.receive_requests[addr] = (amount, message) + self.wallet.storage.put('receive_requests', self.receive_requests) + self.update_receive_tab() + + def new_receive_address(self): + domain = self.wallet.get_account_addresses(self.current_account, include_change=False) + for addr in domain: + if not self.wallet.history.get(addr) and addr not in self.receive_requests.keys(): + break + else: + if isinstance(self.wallet, Imported_Wallet): + self.show_message(_('No more addresses in your wallet.')) + return + if not self.question(_("Warning: The next address will not be recovered automatically if you restore your wallet from seed; you may need to add it manually.\n\nThis occurs because you have too many unused addresses in your wallet. To avoid this situation, use the existing addresses first.\n\nCreate anyway?")): + return + addr = self.wallet.create_new_address(self.current_account, False) + self.receive_address_e.setText(addr) + self.receive_message_e.setText('') + self.receive_amount_e.setAmount(None) + + def clear_receive_tab(self): + self.receive_requests = self.wallet.storage.get('receive_requests',{}) + domain = self.wallet.get_account_addresses(self.current_account, include_change=False) + for addr in domain: + if not self.wallet.history.get(addr) and addr not in self.receive_requests.keys(): + break + else: + addr = '' + self.receive_address_e.setText(addr) + self.receive_message_e.setText('') + self.receive_amount_e.setAmount(None) + + def receive_at(self, addr): + if not bitcoin.is_address(addr): + return + self.tabs.setCurrentIndex(2) + self.receive_address_e.setText(addr) + + def update_receive_tab(self): + self.receive_requests = self.wallet.storage.get('receive_requests',{}) + b = len(self.receive_requests) > 0 + self.receive_list.setVisible(b) + self.receive_requests_label.setVisible(b) + + self.receive_list.clear() + for address, v in self.receive_requests.items(): + amount, message = v + item = QTreeWidgetItem( [ address, message, self.format_amount(amount) if amount else ""] ) + item.setFont(0, QFont(MONOSPACE_FONT)) + self.receive_list.addTopLevelItem(item) + + + def update_receive_qr(self): + import urlparse, urllib + addr = str(self.receive_address_e.text()) + amount = self.receive_amount_e.get_amount() + message = unicode(self.receive_message_e.text()).encode('utf8') + self.save_request_button.setEnabled((amount is not None) or (message != "")) + if addr: + query = [] + if amount: + query.append('amount=%s'%format_satoshis(amount)) + if message: + query.append('message=%s'%urllib.quote(message)) + p = urlparse.ParseResult(scheme='bitcoin', netloc='', path=addr, params='', query='&'.join(query), fragment='') + url = urlparse.urlunparse(p) + else: + url = "" + self.receive_qr.setData(url) + run_hook('update_receive_qr', addr, amount, message, url) + + def create_send_tab(self): w = QWidget() - grid = QGridLayout(w) + self.send_grid = grid = QGridLayout(w) grid.setSpacing(8) grid.setColumnMinimumWidth(3,300) grid.setColumnStretch(5,1) grid.setRowStretch(8, 1) from paytoedit import PayToEdit - self.amount_e = AmountEdit(self.get_decimal_point) - self.payto_e = PayToEdit(self.amount_e) + self.amount_e = BTCAmountEdit(self.get_decimal_point) + self.payto_e = PayToEdit(self) self.payto_help = HelpButton(_('Recipient of the funds.') + '\n\n' + _('You may enter a Bitcoin address, a label from your list of contacts (a list of completions will be proposed), or an alias (email-like address that forwards to a Bitcoin address)')) grid.addWidget(QLabel(_('Pay to')), 1, 0) grid.addWidget(self.payto_e, 1, 1, 1, 3) @@ -684,7 +870,7 @@ class ElectrumWindow(QMainWindow): grid.addWidget(self.amount_e, 4, 1, 1, 2) grid.addWidget(self.amount_help, 4, 3) - self.fee_e = AmountEdit(self.get_decimal_point) + self.fee_e = BTCAmountEdit(self.get_decimal_point) grid.addWidget(QLabel(_('Fee')), 5, 0) grid.addWidget(self.fee_e, 5, 1, 1, 2) grid.addWidget(HelpButton( @@ -692,8 +878,6 @@ class ElectrumWindow(QMainWindow): + _('The amount of fee can be decided freely by the sender. However, transactions with low fees take more time to be processed.') + '\n\n'\ + _('A suggested fee is automatically added to this field. You may override it. The suggested fee increases with the size of the transaction.')), 5, 3) - run_hook('exchange_rate_button', grid) - self.send_button = EnterButton(_("Send"), self.do_send) grid.addWidget(self.send_button, 6, 1) @@ -708,7 +892,6 @@ class ElectrumWindow(QMainWindow): w.setLayout(grid) def entry_changed( is_fee ): - self.funds_error = False if self.amount_e.is_shortcut: self.amount_e.is_shortcut = False @@ -717,28 +900,34 @@ class ElectrumWindow(QMainWindow): inputs, total, fee = self.wallet.choose_tx_inputs( sendable, 0, 1, coins = self.get_coins()) fee = self.wallet.estimated_fee(inputs, 1) amount = total - fee - self.amount_e.setText( self.format_amount(amount) ) - self.fee_e.setText( self.format_amount( fee ) ) + self.amount_e.setAmount(amount) + self.amount_e.textEdited.emit("") + self.fee_e.setAmount(fee) return amount = self.amount_e.get_amount() fee = self.fee_e.get_amount() + outputs = self.payto_e.get_outputs() + + if not is_fee: + fee = None - if not is_fee: fee = None if amount is None: - return - # assume that there will be 2 outputs (one for change) - inputs, total, fee = self.wallet.choose_tx_inputs(amount, fee, 2, coins = self.get_coins()) - if not is_fee: - self.fee_e.setText( self.format_amount( fee ) ) - if inputs: + self.fee_e.setAmount(None) + not_enough_funds = False + else: + inputs, total, fee = self.wallet.choose_tx_inputs(amount, fee, len(outputs), coins = self.get_coins()) + not_enough_funds = len(inputs) == 0 + if not is_fee: + self.fee_e.setAmount(fee) + + if not not_enough_funds: palette = QPalette() palette.setColor(self.amount_e.foregroundRole(), QColor('black')) text = "" else: palette = QPalette() palette.setColor(self.amount_e.foregroundRole(), QColor('red')) - self.funds_error = True text = _( "Not enough funds" ) c, u = self.wallet.get_frozen_balance() if c+u: text += ' (' + self.format_amount(c+u).strip() + ' ' + self.base_unit() + ' ' +_("are frozen") + ')' @@ -794,11 +983,16 @@ class ElectrumWindow(QMainWindow): return lambda s, *args: s.do_protect(func, args) - def do_send(self): + def read_send_tab(self): + + if self.payment_request and self.payment_request.has_expired(): + QMessageBox.warning(self, _('Error'), _('Payment request has expired'), _('OK')) + return + label = unicode( self.message_e.text() ) - if self.gui_object.payment_request: - outputs = self.gui_object.payment_request.outputs + if self.payment_request: + outputs = self.payment_request.get_outputs() else: outputs = self.payto_e.get_outputs() @@ -806,25 +1000,29 @@ class ElectrumWindow(QMainWindow): QMessageBox.warning(self, _('Error'), _('No outputs'), _('OK')) return - for addr, x in outputs: - if addr is None or not bitcoin.is_address(addr): + for type, addr, amount in outputs: + if addr is None: + QMessageBox.warning(self, _('Error'), _('Bitcoin Address is None'), _('OK')) + return + if type == 'op_return': + continue + if type == 'address' and not bitcoin.is_address(addr): QMessageBox.warning(self, _('Error'), _('Invalid Bitcoin Address'), _('OK')) return - if x is None: + if amount is None: QMessageBox.warning(self, _('Error'), _('Invalid Amount'), _('OK')) return - amount = sum(map(lambda x:x[1], outputs)) + amount = sum(map(lambda x:x[2], outputs)) - try: - fee = self.fee_e.get_amount() - except Exception: + fee = self.fee_e.get_amount() + if fee is None: QMessageBox.warning(self, _('Error'), _('Invalid Fee'), _('OK')) return confirm_amount = self.config.get('confirm_amount', 100000000) if amount >= confirm_amount: - o = '\n'.join(map(lambda x:x[0], outputs)) + o = '\n'.join(map(lambda x:x[1], outputs)) if not self.question(_("send %(amount)s to %(address)s?")%{ 'amount' : self.format_amount(amount) + ' '+ self.base_unit(), 'address' : o}): return @@ -833,16 +1031,23 @@ class ElectrumWindow(QMainWindow): if not self.question(_("The fee for this transaction seems unusually high.\nAre you really sure you want to pay %(fee)s in fees?")%{ 'fee' : self.format_amount(fee) + ' '+ self.base_unit()}): return - self.send_tx(outputs, fee, label) + coins = self.get_coins() + return outputs, fee, label, coins + + def do_send(self): + r = self.read_send_tab() + if not r: + return + outputs, fee, label, coins = r + self.send_tx(outputs, fee, label, coins) @protected - def send_tx(self, outputs, fee, label, password): + def send_tx(self, outputs, fee, label, coins, password): self.send_button.setDisabled(True) # first, create an unsigned tx - coins = self.get_coins() try: tx = self.wallet.make_unsigned_transaction(outputs, fee, None, coins = coins) tx.error = None @@ -857,13 +1062,18 @@ class ElectrumWindow(QMainWindow): # sign the tx def sign_thread(): - time.sleep(0.1) + if self.wallet.is_watching_only(): + return tx keypairs = {} - self.wallet.add_keypairs_from_wallet(tx, keypairs, password) - self.wallet.sign_transaction(tx, keypairs, password) - return tx, fee, label + try: + self.wallet.add_keypairs(tx, keypairs, password) + self.wallet.sign_transaction(tx, keypairs, password) + except Exception as e: + traceback.print_exc(file=sys.stdout) + tx.error = str(e) + return tx - def sign_done(tx, fee, label): + def sign_done(tx): if tx.error: self.show_message(tx.error) self.send_button.setDisabled(False) @@ -883,6 +1093,7 @@ class ElectrumWindow(QMainWindow): self.broadcast_transaction(tx) + # keep a reference to WaitingDialog or the gui might crash self.waiting_dialog = WaitingDialog(self, 'Signing..', sign_thread, sign_done) self.waiting_dialog.start() @@ -891,12 +1102,27 @@ class ElectrumWindow(QMainWindow): def broadcast_transaction(self, tx): def broadcast_thread(): - if self.gui_object.payment_request: - refund_address = self.wallet.addresses()[0] - status, msg = self.gui_object.payment_request.send_ack(str(tx), refund_address) - self.gui_object.payment_request = None - else: - status, msg = self.wallet.sendtx(tx) + pr = self.payment_request + if pr is None: + return self.wallet.sendtx(tx) + + if pr.has_expired(): + self.payment_request = None + return False, _("Payment request has expired") + + status, msg = self.wallet.sendtx(tx) + if not status: + return False, msg + + self.invoices[pr.get_id()] = (pr.get_domain(), pr.get_memo(), pr.get_amount(), pr.get_expiration_date(), PR_PAID, tx.hash()) + self.wallet.storage.put('invoices', self.invoices) + self.update_invoices_tab() + self.payment_request = None + refund_address = self.wallet.addresses()[0] + ack_status, ack_msg = pr.send_ack(str(tx), refund_address) + if ack_status: + msg = ack_msg + return status, msg def broadcast_done(status, msg): @@ -923,42 +1149,80 @@ class ElectrumWindow(QMainWindow): return True def payment_request_ok(self): - pr = self.gui_object.payment_request + pr = self.payment_request pr_id = pr.get_id() - # save it - invoices = self.wallet.storage.get('invoices', {}) - invoices[pr_id] = (pr.get_domain(), pr.get_amount()) - invoices = self.wallet.storage.put('invoices', invoices) - self.update_invoices_tab() + if pr_id not in self.invoices: + self.invoices[pr_id] = (pr.get_domain(), pr.get_memo(), pr.get_amount(), pr.get_expiration_date(), PR_UNPAID, None) + self.wallet.storage.put('invoices', self.invoices) + self.update_invoices_tab() + else: + print_error('invoice already in list') + + status = self.invoices[pr_id][4] + if status == PR_PAID: + self.do_clear() + self.show_message("invoice already paid") + self.payment_request = None + return self.payto_help.show() - self.payto_help.set_alt(pr.status) - self.payto_e.setGreen() + self.payto_help.set_alt(lambda: self.show_pr_details(pr)) + + if not pr.has_expired(): + self.payto_e.setGreen() + else: + self.payto_e.setExpired() + self.payto_e.setText(pr.domain) self.amount_e.setText(self.format_amount(pr.get_amount())) - self.message_e.setText(pr.memo) + self.message_e.setText(pr.get_memo()) def payment_request_error(self): self.do_clear() - self.show_message(self.gui_object.payment_request.error) - self.gui_object.payment_request = None + self.show_message(self.payment_request.error) + self.payment_request = None - def set_send(self, address, amount, label, message): - - if label and self.wallet.labels.get(address) != label: - if self.question('Give label "%s" to address %s ?'%(label,address)): - if address not in self.wallet.addressbook and not self.wallet.is_mine(address): - self.wallet.addressbook.append(address) - self.wallet.set_label(address, label) + def pay_from_URI(self,URI): + if not URI: + return + address, amount, label, message, request_url = util.parse_URI(URI) + try: + address, amount, label, message, request_url = util.parse_URI(URI) + except Exception as e: + QMessageBox.warning(self, _('Error'), _('Invalid bitcoin URI:') + '\n' + str(e), _('OK')) + return self.tabs.setCurrentIndex(1) - label = self.wallet.labels.get(address) - m_addr = label + ' <'+ address +'>' if label else address - self.payto_e.setText(m_addr) - self.message_e.setText(message) - if amount: - self.amount_e.setText(amount) + if not request_url: + if label: + if self.wallet.labels.get(address) != label: + if self.question(_('Save label "%s" for address %s ?'%(label,address))): + if address not in self.wallet.addressbook and not self.wallet.is_mine(address): + self.wallet.addressbook.append(address) + self.wallet.set_label(address, label) + else: + label = self.wallet.labels.get(address) + if address: + self.payto_e.setText(label + ' <'+ address +'>' if label else address) + if message: + self.message_e.setText(message) + if amount: + self.amount_e.setAmount(amount) + return + + from electrum import paymentrequest + def payment_request(): + self.payment_request = paymentrequest.PaymentRequest(self.config) + self.payment_request.read(request_url) + if self.payment_request.verify(): + self.emit(SIGNAL('payment_request_ok')) + else: + self.emit(SIGNAL('payment_request_error')) + + self.pr_thread = threading.Thread(target=payment_request).start() + self.prepare_for_payment_request() + def do_clear(self): @@ -972,7 +1236,6 @@ class ElectrumWindow(QMainWindow): h.show() self.payto_help.set_alt(None) - self.set_pay_from([]) self.update_status() @@ -985,7 +1248,7 @@ class ElectrumWindow(QMainWindow): self.wallet.unfreeze(addr) elif addr not in self.wallet.frozen_addresses and freeze: self.wallet.freeze(addr) - self.update_receive_tab() + self.update_address_tab() @@ -1005,25 +1268,20 @@ class ElectrumWindow(QMainWindow): buttons = QWidget() vbox.addWidget(buttons) - hbox = QHBoxLayout() - hbox.setMargin(0) - hbox.setSpacing(0) - buttons.setLayout(hbox) - - return l,w,hbox + return l, w - def create_receive_tab(self): - l,w,hbox = self.create_list_tab([ _('Address'), _('Label'), _('Balance'), _('Tx')]) + def create_addresses_tab(self): + l, w = self.create_list_tab([ _('Address'), _('Label'), _('Balance'), _('Tx')]) + for i,width in enumerate(self.column_widths['receive']): + l.setColumnWidth(i, width) l.setContextMenuPolicy(Qt.CustomContextMenu) l.customContextMenuRequested.connect(self.create_receive_menu) l.setSelectionMode(QAbstractItemView.ExtendedSelection) - self.connect(l, SIGNAL('itemDoubleClicked(QTreeWidgetItem*, int)'), lambda a, b: self.address_label_clicked(a,b,l,0,1)) - self.connect(l, SIGNAL('itemChanged(QTreeWidgetItem*, int)'), lambda a,b: self.address_label_changed(a,b,l,0,1)) - self.connect(l, SIGNAL('currentItemChanged(QTreeWidgetItem*, QTreeWidgetItem*)'), lambda a,b: self.current_item_changed(a)) - self.receive_list = l - self.receive_buttons_hbox = hbox - hbox.addStretch(1) + l.itemDoubleClicked.connect(lambda a, b: self.address_label_clicked(a,b,l,0,1)) + l.itemChanged.connect(lambda a,b: self.address_label_changed(a,b,l,0,1)) + l.currentItemChanged.connect(lambda a,b: self.current_item_changed(a)) + self.address_list = l return w @@ -1031,8 +1289,8 @@ class ElectrumWindow(QMainWindow): def save_column_widths(self): self.column_widths["receive"] = [] - for i in range(self.receive_list.columnCount() -1): - self.column_widths["receive"].append(self.receive_list.columnWidth(i)) + for i in range(self.address_list.columnCount() -1): + self.column_widths["receive"].append(self.address_list.columnWidth(i)) self.column_widths["history"] = [] for i in range(self.history_list.columnCount() - 1): @@ -1046,38 +1304,41 @@ class ElectrumWindow(QMainWindow): def create_contacts_tab(self): - l,w,hbox = self.create_list_tab([_('Address'), _('Label'), _('Tx')]) + l, w = self.create_list_tab([_('Address'), _('Label'), _('Tx')]) l.setContextMenuPolicy(Qt.CustomContextMenu) l.customContextMenuRequested.connect(self.create_contact_menu) for i,width in enumerate(self.column_widths['contacts']): l.setColumnWidth(i, width) - - self.connect(l, SIGNAL('itemDoubleClicked(QTreeWidgetItem*, int)'), lambda a, b: self.address_label_clicked(a,b,l,0,1)) - self.connect(l, SIGNAL('itemChanged(QTreeWidgetItem*, int)'), lambda a,b: self.address_label_changed(a,b,l,0,1)) + l.itemDoubleClicked.connect(lambda a, b: self.address_label_clicked(a,b,l,0,1)) + l.itemChanged.connect(lambda a,b: self.address_label_changed(a,b,l,0,1)) self.contacts_list = l - self.contacts_buttons_hbox = hbox - hbox.addStretch(1) return w def create_invoices_tab(self): - l,w,hbox = self.create_list_tab([_('Recipient'), _('Amount'), _('Status')]) + l, w = self.create_list_tab([_('Requestor'), _('Memo'),_('Amount'), _('Status')]) + l.setColumnWidth(0, 150) + h = l.header() + h.setStretchLastSection(False) + h.setResizeMode(1, QHeaderView.Stretch) l.setContextMenuPolicy(Qt.CustomContextMenu) - #l.customContextMenuRequested.connect(self.create_contact_menu) - #self.connect(l, SIGNAL('itemDoubleClicked(QTreeWidgetItem*, int)'), lambda a, b: self.address_label_clicked(a,b,l,0,1)) - #self.connect(l, SIGNAL('itemChanged(QTreeWidgetItem*, int)'), lambda a,b: self.address_label_changed(a,b,l,0,1)) + l.customContextMenuRequested.connect(self.create_invoice_menu) self.invoices_list = l - hbox.addStretch(1) return w def update_invoices_tab(self): invoices = self.wallet.storage.get('invoices', {}) l = self.invoices_list l.clear() - - for item, value in invoices.items(): - domain, amount = value - item = QTreeWidgetItem( [ domain, self.format_amount(amount), ""] ) + for key, value in invoices.items(): + try: + domain, memo, amount, expiration_date, status, tx_hash = value + except: + invoices.pop(key) + continue + if status == PR_UNPAID and expiration_date and expiration_date < time.time(): + status = PR_EXPIRED + item = QTreeWidgetItem( [ domain, memo, self.format_amount(amount), format_status(status)] ) l.addTopLevelItem(item) l.setCurrentItem(l.topLevelItem(0)) @@ -1087,7 +1348,7 @@ class ElectrumWindow(QMainWindow): def delete_imported_key(self, addr): if self.question(_("Do you want to remove")+" %s "%addr +_("from your wallet?")): self.wallet.delete_imported_key(addr) - self.update_receive_tab() + self.update_address_tab() self.update_history_tab() def edit_account_label(self, k): @@ -1095,7 +1356,7 @@ class ElectrumWindow(QMainWindow): if ok: label = unicode(text) self.wallet.set_label(k,label) - self.update_receive_tab() + self.update_address_tab() def account_set_expanded(self, item, k, b): item.setExpanded(b) @@ -1112,22 +1373,22 @@ class ElectrumWindow(QMainWindow): menu.addAction(_("View details"), lambda: self.show_account_details(k)) if self.wallet.account_is_pending(k): menu.addAction(_("Delete"), lambda: self.delete_pending_account(k)) - menu.exec_(self.receive_list.viewport().mapToGlobal(position)) + menu.exec_(self.address_list.viewport().mapToGlobal(position)) def delete_pending_account(self, k): self.wallet.delete_pending_account(k) - self.update_receive_tab() + self.update_address_tab() def create_receive_menu(self, position): # fixme: this function apparently has a side effect. # if it is not called the menu pops up several times - #self.receive_list.selectedIndexes() + #self.address_list.selectedIndexes() - selected = self.receive_list.selectedItems() + selected = self.address_list.selectedItems() multi_select = len(selected) > 1 addrs = [unicode(item.text(0)) for item in selected] if not multi_select: - item = self.receive_list.itemAt(position) + item = self.address_list.itemAt(position) if not item: return addr = addrs[0] @@ -1142,13 +1403,13 @@ class ElectrumWindow(QMainWindow): menu = QMenu() if not multi_select: menu.addAction(_("Copy to clipboard"), lambda: self.app.clipboard().setText(addr)) - menu.addAction(_("QR code"), lambda: self.show_qrcode("bitcoin:" + addr, _("Address")) ) + menu.addAction(_("Request payment"), lambda: self.receive_at(addr)) menu.addAction(_("Edit label"), lambda: self.edit_label(True)) menu.addAction(_("Public keys"), lambda: self.show_public_keys(addr)) if not self.wallet.is_watching_only(): menu.addAction(_("Private key"), lambda: self.show_private_key(addr)) menu.addAction(_("Sign/verify message"), lambda: self.sign_verify_message(addr)) - #menu.addAction(_("Encrypt/decrypt message"), lambda: self.encrypt_message(addr)) + menu.addAction(_("Encrypt/decrypt message"), lambda: self.encrypt_message(addr)) if self.wallet.is_imported(addr): menu.addAction(_("Remove from wallet"), lambda: self.delete_imported_key(addr)) @@ -1157,11 +1418,13 @@ class ElectrumWindow(QMainWindow): if any(addr in self.wallet.frozen_addresses for addr in addrs): menu.addAction(_("Unfreeze"), lambda: self.set_addrs_frozen(addrs, False)) - if any(addr not in self.wallet.frozen_addresses for addr in addrs): + def can_send(addr): + return addr not in self.wallet.frozen_addresses and self.wallet.get_addr_balance(addr) != (0, 0) + if any(can_send(addr) for addr in addrs): menu.addAction(_("Send From"), lambda: self.send_from_addresses(addrs)) run_hook('receive_menu', menu, addrs) - menu.exec_(self.receive_list.viewport().mapToGlobal(position)) + menu.exec_(self.address_list.viewport().mapToGlobal(position)) def get_sendable_balance(self): @@ -1221,35 +1484,65 @@ class ElectrumWindow(QMainWindow): run_hook('create_contact_menu', menu, item) menu.exec_(self.contacts_list.viewport().mapToGlobal(position)) + def delete_invoice(self, key): + self.invoices.pop(key) + self.wallet.storage.put('invoices', self.invoices) + self.update_invoices_tab() - def update_receive_item(self, item): - item.setFont(0, QFont(MONOSPACE_FONT)) - address = str(item.data(0,0).toString()) - label = self.wallet.labels.get(address,'') - item.setData(1,0,label) - item.setData(0,32, True) # is editable - - run_hook('update_receive_item', address, item) - - if not self.wallet.is_mine(address): return + def show_invoice(self, key): + from electrum.paymentrequest import PaymentRequest + domain, memo, value, expiration, status, tx_hash = self.invoices[key] + pr = PaymentRequest(self.config) + pr.read_file(key) + pr.domain = domain + pr.verify() + self.show_pr_details(pr) + + def show_pr_details(self, pr): + msg = 'Domain: ' + pr.domain + msg += '\nStatus: ' + pr.get_status() + msg += '\nMemo: ' + pr.get_memo() + msg += '\nPayment URL: ' + pr.payment_url + msg += '\n\nOutputs:\n' + '\n'.join(map(lambda x: x[0] + ' ' + self.format_amount(x[1])+ self.base_unit(), pr.get_outputs())) + QMessageBox.information(self, 'Invoice', msg , 'OK') + + def do_pay_invoice(self, key): + from electrum.paymentrequest import PaymentRequest + domain, memo, value, expiration, status, tx_hash = self.invoices[key] + pr = PaymentRequest(self.config) + pr.read_file(key) + pr.domain = domain + self.payment_request = pr + self.prepare_for_payment_request() + if pr.verify(): + self.payment_request_ok() + else: + self.payment_request_error() + - c, u = self.wallet.get_addr_balance(address) - balance = self.format_amount(c + u) - item.setData(2,0,balance) + def create_invoice_menu(self, position): + item = self.invoices_list.itemAt(position) + if not item: + return + k = self.invoices_list.indexOfTopLevelItem(item) + key = self.invoices.keys()[k] + domain, memo, value, expiration, status, tx_hash = self.invoices[key] + menu = QMenu() + menu.addAction(_("Details"), lambda: self.show_invoice(key)) + if status == PR_UNPAID: + menu.addAction(_("Pay Now"), lambda: self.do_pay_invoice(key)) + menu.addAction(_("Delete"), lambda: self.delete_invoice(key)) + menu.exec_(self.invoices_list.viewport().mapToGlobal(position)) - if address in self.wallet.frozen_addresses: - item.setBackgroundColor(0, QColor('lightblue')) - def update_receive_tab(self): - l = self.receive_list + def update_address_tab(self): + l = self.address_list # extend the syntax for consistency l.addChild = l.addTopLevelItem l.insertChild = l.insertTopLevelItem l.clear() - for i,width in enumerate(self.column_widths['receive']): - l.setColumnWidth(i, width) accounts = self.wallet.get_accounts() if self.current_account is None: @@ -1284,27 +1577,22 @@ class ElectrumWindow(QMainWindow): used_item = QTreeWidgetItem( [ _("Used"), '', '', '', ''] ) used_flag = False - is_red = False - gap = 0 - - for address in account.get_addresses(is_change): - + addr_list = account.get_addresses(is_change) + for address in addr_list: num, is_used = self.wallet.is_used(address) - if num == 0: - gap += 1 - if gap > self.wallet.gap_limit: - is_red = True - else: - gap = 0 - - item = QTreeWidgetItem( [ address, '', '', "%d"%num] ) - self.update_receive_item(item) - if is_red: - item.setBackgroundColor(1, QColor('red')) - + label = self.wallet.labels.get(address,'') + c, u = self.wallet.get_addr_balance(address) + balance = self.format_amount(c + u) + item = QTreeWidgetItem( [ address, label, balance, "%d"%num] ) + item.setFont(0, QFont(MONOSPACE_FONT)) + item.setData(0, 32, True) # label can be edited + if address in self.wallet.frozen_addresses: + item.setBackgroundColor(0, QColor('lightblue')) + if self.wallet.is_beyond_limit(address, account, is_change): + item.setBackgroundColor(0, QColor('red')) if is_used: if not used_flag: - seq_item.insertChild(0,used_item) + seq_item.insertChild(0, used_item) used_flag = True used_item.addChild(item) else: @@ -1333,7 +1621,6 @@ class ElectrumWindow(QMainWindow): l.setCurrentItem(l.topLevelItem(0)) - def create_console_tab(self): from console import Console self.console = console = Console() @@ -1369,6 +1656,7 @@ class ElectrumWindow(QMainWindow): self.current_account = k self.update_history_tab() self.update_status() + self.update_address_tab() self.update_receive_tab() def create_status_bar(self): @@ -1496,8 +1784,8 @@ class ElectrumWindow(QMainWindow): if not name: return self.wallet.create_pending_account(name, password) - self.update_receive_tab() - self.tabs.setCurrentIndex(2) + self.update_address_tab() + self.tabs.setCurrentIndex(3) @@ -1546,44 +1834,9 @@ class ElectrumWindow(QMainWindow): def show_qrcode(self, data, title = _("QR code")): - if not data: return - d = QDialog(self) - d.setModal(1) - d.setWindowTitle(title) - d.setMinimumSize(270, 300) - vbox = QVBoxLayout() - qrw = QRCodeWidget(data) - vbox.addWidget(qrw, 1) - vbox.addWidget(QLabel(data), 0, Qt.AlignHCenter) - hbox = QHBoxLayout() - hbox.addStretch(1) - - filename = os.path.join(self.config.path, "qrcode.bmp") - - def print_qr(): - bmp.save_qrcode(qrw.qr, filename) - QMessageBox.information(None, _('Message'), _("QR code saved to file") + " " + filename, _('OK')) - - def copy_to_clipboard(): - bmp.save_qrcode(qrw.qr, filename) - self.app.clipboard().setImage(QImage(filename)) - QMessageBox.information(None, _('Message'), _("QR code saved to clipboard"), _('OK')) - - b = QPushButton(_("Copy")) - hbox.addWidget(b) - b.clicked.connect(copy_to_clipboard) - - b = QPushButton(_("Save")) - hbox.addWidget(b) - b.clicked.connect(print_qr) - - b = QPushButton(_("Close")) - hbox.addWidget(b) - b.clicked.connect(d.accept) - b.setDefault(True) - - vbox.addLayout(hbox) - d.setLayout(vbox) + if not data: + return + d = QRDialog(data, self, title) d.exec_() @@ -1617,11 +1870,10 @@ class ElectrumWindow(QMainWindow): vbox = QVBoxLayout() vbox.addWidget( QLabel(_("Address") + ': ' + address)) vbox.addWidget( QLabel(_("Public key") + ':')) - keys = QTextEdit() + keys = QRTextEdit() keys.setReadOnly(True) keys.setText('\n'.join(pubkey_list)) vbox.addWidget(keys) - #vbox.addWidget( QRCodeWidget('\n'.join(pk_list)) ) vbox.addLayout(close_button(d)) d.setLayout(vbox) d.exec_() @@ -1642,11 +1894,10 @@ class ElectrumWindow(QMainWindow): vbox = QVBoxLayout() vbox.addWidget( QLabel(_("Address") + ': ' + address)) vbox.addWidget( QLabel(_("Private key") + ':')) - keys = QTextEdit() + keys = QRTextEdit() keys.setReadOnly(True) keys.setText('\n'.join(pk_list)) vbox.addWidget(keys) - vbox.addWidget( QRCodeWidget('\n'.join(pk_list)) ) vbox.addLayout(close_button(d)) d.setLayout(vbox) d.exec_() @@ -1746,7 +1997,7 @@ class ElectrumWindow(QMainWindow): pubkey_e = QLineEdit() if address: - pubkey = self.wallet.getpubkeys(address)[0] + pubkey = self.wallet.get_public_keys(address)[0] pubkey_e.setText(pubkey) layout.addWidget(QLabel(_('Public key')), 2, 0) layout.addWidget(pubkey_e, 2, 1) @@ -1816,25 +2067,45 @@ class ElectrumWindow(QMainWindow): "json or raw hexadecimal" try: txt.decode('hex') - tx = Transaction(txt) - return tx - except Exception: - pass + is_hex = True + except: + is_hex = False + + if is_hex: + try: + return Transaction.deserialize(txt) + except: + traceback.print_exc(file=sys.stdout) + QMessageBox.critical(None, _("Unable to parse transaction"), _("Electrum was unable to parse your transaction")) + return try: tx_dict = json.loads(str(txt)) assert "hex" in tx_dict.keys() - tx = Transaction(tx_dict["hex"]) - if tx_dict.has_key("input_info"): - input_info = json.loads(tx_dict['input_info']) - tx.add_input_info(input_info) + tx = Transaction.deserialize(tx_dict["hex"]) + #if tx_dict.has_key("input_info"): + # input_info = json.loads(tx_dict['input_info']) + # tx.add_input_info(input_info) return tx except Exception: traceback.print_exc(file=sys.stdout) - pass + QMessageBox.critical(None, _("Unable to parse transaction"), _("Electrum was unable to parse your transaction")) - QMessageBox.critical(None, _("Unable to parse transaction"), _("Electrum was unable to parse your transaction")) + def read_tx_from_qrcode(self): + data = run_hook('scan_qr_hook') + if not data: + return + # transactions are binary, but qrcode seems to return utf8... + z = data.decode('utf8') + s = '' + for b in z: + s += chr(ord(b)) + data = s.encode('hex') + tx = self.tx_from_text(data) + if not tx: + return + self.show_transaction(tx) def read_tx_from_file(self): @@ -1851,8 +2122,12 @@ class ElectrumWindow(QMainWindow): @protected - def sign_raw_transaction(self, tx, input_info, password): - self.wallet.signrawtransaction(tx, input_info, [], password) + def sign_raw_transaction(self, tx, password): + try: + self.wallet.signrawtransaction(tx, [], password) + except Exception as e: + traceback.print_exc(file=sys.stdout) + QMessageBox.warning(self, _("Error"), str(e)) def do_process_from_text(self): text = text_dialog(self, _('Input raw transaction'), _("Transaction:"), _("Load transaction")) @@ -1873,7 +2148,7 @@ class ElectrumWindow(QMainWindow): if ok and txid: r = self.network.synchronous_get([ ('blockchain.transaction.get',[str(txid)]) ])[0] if r: - tx = transaction.Transaction(r) + tx = transaction.Transaction.deserialize(r) if tx: self.show_transaction(tx) else: @@ -1886,12 +2161,12 @@ class ElectrumWindow(QMainWindow): try: for position, row in enumerate(csvReader): address = row[0] - if not is_valid(address): + if not is_address(address): errors.append((position, address)) continue amount = Decimal(row[1]) amount = int(100000000*amount) - outputs.append((address, amount)) + outputs.append(('address', address, amount)) except (ValueError, IOError, os.error), reason: QMessageBox.critical(None, _("Unable to read file or no transaction found"), _("Electrum was unable to open your transaction file") + "\n" + str(reason)) return @@ -2194,7 +2469,7 @@ class ElectrumWindow(QMainWindow): QMessageBox.information(self, _('Information'), _("The following addresses were added") + ':\n' + '\n'.join(addrlist)) if badkeys: QMessageBox.critical(self, _('Error'), _("The following inputs could not be imported") + ':\n'+ '\n'.join(badkeys)) - self.update_receive_tab() + self.update_address_tab() self.update_history_tab() @@ -2234,16 +2509,16 @@ class ElectrumWindow(QMainWindow): fee_label = QLabel(_('Transaction fee') + ':') grid.addWidget(fee_label, 2, 0) - fee_e = AmountEdit(self.get_decimal_point) - fee_e.setText(self.format_amount(self.wallet.fee).strip()) + fee_e = BTCAmountEdit(self.get_decimal_point) + fee_e.setAmount(self.wallet.fee) grid.addWidget(fee_e, 2, 1) - msg = _('Fee per kilobyte of transaction.') + ' ' \ - + _('Recommended value') + ': ' + self.format_amount(20000) + msg = _('Fee per kilobyte of transaction.') + '\n' \ + + _('Recommended value') + ': ' + self.format_amount(10000) + ' ' + self.base_unit() grid.addWidget(HelpButton(msg), 2, 2) if not self.config.is_modifiable('fee_per_kb'): for w in [fee_e, fee_label]: w.setEnabled(False) - units = ['BTC', 'mBTC'] + units = ['BTC', 'mBTC', 'bits'] unit_label = QLabel(_('Base unit') + ':') grid.addWidget(unit_label, 3, 0) unit_combo = QComboBox() @@ -2283,9 +2558,8 @@ class ElectrumWindow(QMainWindow): # run the dialog if not d.exec_(): return - try: - fee = self.fee_e.get_amount() - except Exception: + fee = fee_e.get_amount() + if fee is None: QMessageBox.warning(self, _('Error'), _('Invalid value') +': %s'%fee, _('OK')) return @@ -2303,7 +2577,7 @@ class ElectrumWindow(QMainWindow): self.num_zeros = nz self.config.set_key('num_zeros', nz, True) self.update_history_tab() - self.update_receive_tab() + self.update_address_tab() usechange_result = usechange_cb.isChecked() if self.wallet.use_change != usechange_result: @@ -2315,7 +2589,14 @@ class ElectrumWindow(QMainWindow): unit_result = units[unit_combo.currentIndex()] if self.base_unit() != unit_result: - self.decimal_point = 8 if unit_result == 'BTC' else 5 + if unit_result == 'BTC': + self.decimal_point = 8 + elif unit_result == 'mBTC': + self.decimal_point = 5 + elif unit_result == 'bits': + self.decimal_point = 2 + else: + raise Exception('Unknown base unit') self.config.set_key('decimal_point', self.decimal_point, True) self.update_history_tab() self.update_status()