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
+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
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):
default_column_widths = { "history":[40,140,350,140], "contacts":[350,330], "receive": [370,200,130] }
class ElectrumWindow(QMainWindow):
- def build_menu(self):
- m = QMenu()
- m.addAction(_("Show/Hide"), self.show_or_hide)
- m.addSeparator()
- m.addAction(_("Exit Electrum"), self.close)
- self.tray.setContextMenu(m)
-
- def show_or_hide(self):
- self.tray_activated(QSystemTrayIcon.DoubleClick)
-
- def tray_activated(self, reason):
- if reason == QSystemTrayIcon.DoubleClick:
- if self.isMinimized() or self.isHidden():
- self.show()
- self.raise_()
- else:
- self.hide()
- def __init__(self, config, network):
+
+
+ def __init__(self, config, network, gui_object):
QMainWindow.__init__(self)
self.config = config
self.network = network
-
- self._close_electrum = False
+ self.gui_object = gui_object
+ self.tray = gui_object.tray
+ self.go_lite = gui_object.go_lite
self.lite = None
- if sys.platform == 'darwin':
- self.icon = QIcon(":icons/electrum_dark_icon.png")
- #self.icon = QIcon(":icons/lock.png")
- else:
- self.icon = QIcon(':icons/electrum_light_icon.png')
-
- self.tray = QSystemTrayIcon(self.icon, self)
- self.tray.setToolTip('Electrum')
- self.tray.activated.connect(self.tray_activated)
-
- self.build_menu()
- self.tray.show()
self.create_status_bar()
-
self.need_update = threading.Event()
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)
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') )
tabs.setMinimumSize(600, 400)
tabs.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)
g = self.config.get("winpos-qt",[100, 100, 840, 400])
self.setGeometry(g[0], g[1], g[2], g[3])
+ if self.config.get("is_maximized"):
+ self.showMaximized()
self.setWindowIcon(QIcon(":icons/electrum.png"))
self.init_menubar()
self.connect(self, QtCore.SIGNAL('update_status'), self.update_status)
self.connect(self, QtCore.SIGNAL('banner_signal'), lambda: self.console.showMessage(self.network.banner) )
self.connect(self, QtCore.SIGNAL('transaction_signal'), lambda: self.notify_transactions() )
- self.connect(self, QtCore.SIGNAL('send_tx2'), self.send_tx2)
- self.connect(self, QtCore.SIGNAL('send_tx3'), self.send_tx3)
+ self.connect(self, QtCore.SIGNAL('payment_request_ok'), self.payment_request_ok)
+ self.connect(self, QtCore.SIGNAL('payment_request_error'), self.payment_request_error)
self.history_list.setFocus(True)
self.console.showMessage(self.network.banner)
self.wallet = None
- self.init_lite()
-
-
- def go_full(self):
- self.config.set_key('lite_mode', False, True)
- self.mini.hide()
- self.show()
- self.raise_()
-
- def go_lite(self):
- self.config.set_key('lite_mode', True, True)
- self.hide()
- self.mini.show()
- self.mini.raise_()
-
-
- def init_lite(self):
- import lite_window
- if not self.check_qt_version():
- if self.config.get('lite_mode') is True:
- msg = "Electrum was unable to load the 'Lite GUI' because it needs Qt version >= 4.7.\nChanging your config to use the 'Classic' GUI"
- QMessageBox.warning(None, "Could not start Lite GUI.", msg)
- self.config.set_key('lite_mode', False, True)
- sys.exit(0)
- self.mini = None
- self.show()
- self.raise_()
- return
-
- actuator = lite_window.MiniActuator(self)
-
- actuator.load_theme()
-
- self.mini = lite_window.MiniWindow(actuator, self.go_full, self.config)
-
- driver = lite_window.MiniDriver(self, self.mini)
-
- if self.config.get('lite_mode') is True:
- self.go_lite()
- else:
- self.go_full()
-
-
- def check_qt_version(self):
- qtVersion = qVersion()
- return int(qtVersion[0]) >= 4 and int(qtVersion[2]) >= 7
-
+ self.payment_request = None
def update_account_selector(self):
# account selector
def load_wallet(self, wallet):
import electrum
+
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
if self.wallet.is_watching_only(): title += ' [%s]' % (_('watching only'))
self.setWindowTitle( title )
# Once GUI has been initialized check if we want to announce something since the callback has been called before the GUI was initialized
self.notify_transactions()
self.update_account_selector()
- self.new_account.setEnabled(self.wallet.can_create_accounts())
+ # update menus
+ self.new_account_menu.setEnabled(self.wallet.can_create_accounts())
+ self.private_keys_menu.setEnabled(not self.wallet.is_watching_only())
+ self.password_menu.setEnabled(not self.wallet.is_watching_only())
+ self.seed_menu.setEnabled(self.wallet.has_seed())
+ self.mpk_menu.setEnabled(self.wallet.is_deterministic())
+ self.import_menu.setEnabled(self.wallet.can_import())
+
self.update_lock_icon()
self.update_buttons_on_seed()
self.update_console()
+ self.clear_receive_tab()
+ self.update_receive_tab()
run_hook('load_wallet', wallet)
+ def update_wallet_format(self):
+ # convert old-format imported keys
+ if self.wallet.imported_keys:
+ password = self.password_dialog(_("Please enter your password in order to update imported keys"))
+ try:
+ self.wallet.convert_imported_keys(password)
+ except:
+ self.show_message("error")
+
+
def open_wallet(self):
wallet_folder = self.wallet.storage.path
filename = unicode( QFileDialog.getOpenFileName(self, "Select your wallet file", wallet_folder) )
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
wizard = installwizard.InstallWizard(self.config, self.network, storage)
- wallet = wizard.run()
+ wallet = wizard.run('new')
if wallet:
self.load_wallet(wallet)
wallet_menu = menubar.addMenu(_("&Wallet"))
wallet_menu.addAction(_("&New contact"), self.new_contact_dialog)
- self.new_account = wallet_menu.addAction(_("&New account"), self.new_account_dialog)
+ self.new_account_menu = wallet_menu.addAction(_("&New account"), self.new_account_dialog)
wallet_menu.addSeparator()
- wallet_menu.addAction(_("&Password"), self.change_password_dialog)
- wallet_menu.addAction(_("&Seed"), self.show_seed_dialog)
- wallet_menu.addAction(_("&Master Public Key"), self.show_master_public_key)
+ self.password_menu = wallet_menu.addAction(_("&Password"), self.change_password_dialog)
+ self.seed_menu = wallet_menu.addAction(_("&Seed"), self.show_seed_dialog)
+ self.mpk_menu = wallet_menu.addAction(_("&Master Public Keys"), self.show_master_public_keys)
wallet_menu.addSeparator()
labels_menu = wallet_menu.addMenu(_("&Labels"))
labels_menu.addAction(_("&Import"), self.do_import_labels)
labels_menu.addAction(_("&Export"), self.do_export_labels)
- keys_menu = wallet_menu.addMenu(_("&Private keys"))
- keys_menu.addAction(_("&Import"), self.do_import_privkey)
- keys_menu.addAction(_("&Export"), self.do_export_privkeys)
-
- wallet_menu.addAction(_("&Export History"), self.do_export_history)
+ self.private_keys_menu = wallet_menu.addMenu(_("&Private keys"))
+ self.private_keys_menu.addAction(_("&Sweep"), self.sweep_key_dialog)
+ self.import_menu = self.private_keys_menu.addAction(_("&Import"), self.do_import_privkey)
+ self.private_keys_menu.addAction(_("&Export"), self.export_privkeys_dialog)
+ wallet_menu.addAction(_("&Export History"), self.export_history_dialog)
tools_menu = menubar.addMenu(_("&Tools"))
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"))
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)
# custom wrappers for getOpenFileName and getSaveFileName, that remember the path selected by the user
def getOpenFileName(self, title, filter = ""):
- directory = self.config.get('io_dir', os.path.expanduser('~'))
+ directory = self.config.get('io_dir', unicode(os.path.expanduser('~')))
fileName = unicode( QFileDialog.getOpenFileName(self, title, directory, filter) )
if fileName and directory != os.path.dirname(fileName):
self.config.set_key('io_dir', os.path.dirname(fileName), True)
return fileName
def getSaveFileName(self, title, filename, filter = ""):
- directory = self.config.get('io_dir', os.path.expanduser('~'))
+ directory = self.config.get('io_dir', unicode(os.path.expanduser('~')))
path = os.path.join( directory, filename )
fileName = unicode( QFileDialog.getSaveFileName(self, title, path, filter) )
if fileName and directory != os.path.dirname(fileName):
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):
return format_satoshis(x, is_diff, self.num_zeros, self.decimal_point, whitespaces)
- def read_amount(self, x):
- if x in['.', '']: return None
- p = pow(10, self.decimal_point)
- return int( p * Decimal(x) )
- def base_unit(self):
- assert self.decimal_point in [5,8]
- return "BTC" if self.decimal_point == 8 else "mBTC"
+ def get_decimal_point(self):
+ return self.decimal_point
+ def base_unit(self):
+ 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():
text = _("Offline")
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()
def create_history_tab(self):
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
def create_history_menu(self, position):
self.history_list.selectedIndexes()
item = self.history_list.currentItem()
+ be = self.config.get('block_explorer', 'Blockchain.info')
+ if be == 'Blockchain.info':
+ block_explorer = 'https://blockchain.info/tx/'
+ elif be == 'Blockr.io':
+ block_explorer = 'https://blockr.io/tx/info/'
+ elif be == 'Insight.is':
+ block_explorer = 'http://live.insight.is/tx/'
if not item: return
tx_hash = str(item.data(0, Qt.UserRole).toString())
if not tx_hash: return
menu.addAction(_("Copy ID to Clipboard"), lambda: self.app.clipboard().setText(tx_hash))
menu.addAction(_("Details"), lambda: self.show_transaction(self.wallet.transactions.get(tx_hash)))
menu.addAction(_("Edit description"), lambda: self.tx_label_clicked(item,2))
- menu.addAction(_("View on Blockchain.info"), lambda: webbrowser.open("https://blockchain.info/tx/" + tx_hash))
+ menu.addAction(_("View on block explorer"), lambda: webbrowser.open(block_explorer + tx_hash))
menu.exec_(self.contacts_list.viewport().mapToGlobal(position))
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 )
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()
+ self.send_grid = grid = QGridLayout(w)
grid.setSpacing(8)
grid.setColumnMinimumWidth(3,300)
grid.setColumnStretch(5,1)
+ grid.setRowStretch(8, 1)
-
- self.payto_e = QLineEdit()
+ from paytoedit import PayToEdit
+ 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)
-
- grid.addWidget(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)')), 1, 4)
+ grid.addWidget(self.payto_help, 1, 4)
completer = QCompleter()
completer.setCaseSensitivity(False)
self.payto_e.setCompleter(completer)
completer.setModel(self.completions)
- self.message_e = QLineEdit()
+ self.message_e = MyLineEdit()
+ self.message_help = HelpButton(_('Description of the transaction (not mandatory).') + '\n\n' + _('The description is not sent to the recipient of the funds. It is stored in your wallet file, and displayed in the \'History\' tab.'))
grid.addWidget(QLabel(_('Description')), 2, 0)
grid.addWidget(self.message_e, 2, 1, 1, 3)
- grid.addWidget(HelpButton(_('Description of the transaction (not mandatory).') + '\n\n' + _('The description is not sent to the recipient of the funds. It is stored in your wallet file, and displayed in the \'History\' tab.')), 2, 4)
+ grid.addWidget(self.message_help, 2, 4)
self.from_label = QLabel(_('From'))
grid.addWidget(self.from_label, 3, 0)
- self.from_list = QTreeWidget(self)
+ self.from_list = MyTreeWidget(self)
self.from_list.setColumnCount(2)
self.from_list.setColumnWidth(0, 350)
self.from_list.setColumnWidth(1, 50)
- self.from_list.setHeaderHidden (True)
+ self.from_list.setHeaderHidden(True)
self.from_list.setMaximumHeight(80)
+ self.from_list.setContextMenuPolicy(Qt.CustomContextMenu)
+ self.from_list.customContextMenuRequested.connect(self.from_list_menu)
grid.addWidget(self.from_list, 3, 1, 1, 3)
self.set_pay_from([])
- self.amount_e = AmountEdit(self.base_unit)
+ self.amount_help = HelpButton(_('Amount to be sent.') + '\n\n' \
+ + _('The amount will be displayed in red if you do not have enough funds in your wallet. Note that if you have frozen some of your addresses, the available funds will be lower than your total balance.') \
+ + '\n\n' + _('Keyboard shortcut: type "!" to send all your coins.'))
grid.addWidget(QLabel(_('Amount')), 4, 0)
grid.addWidget(self.amount_e, 4, 1, 1, 2)
- grid.addWidget(HelpButton(
- _('Amount to be sent.') + '\n\n' \
- + _('The amount will be displayed in red if you do not have enough funds in your wallet. Note that if you have frozen some of your addresses, the available funds will be lower than your total balance.') \
- + '\n\n' + _('Keyboard shortcut: type "!" to send all your coins.')), 4, 3)
+ grid.addWidget(self.amount_help, 4, 3)
- self.fee_e = AmountEdit(self.base_unit)
+ 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(
+ _('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)
- b = EnterButton(_("Clear"),self.do_clear)
+ b = EnterButton(_("Clear"), self.do_clear)
grid.addWidget(b, 6, 2)
self.payto_sig = QLabel('')
grid.addWidget(self.payto_sig, 7, 0, 1, 4)
- QShortcut(QKeySequence("Up"), w, w.focusPreviousChild)
- QShortcut(QKeySequence("Down"), w, w.focusNextChild)
+ #QShortcut(QKeySequence("Up"), w, w.focusPreviousChild)
+ #QShortcut(QKeySequence("Down"), w, w.focusNextChild)
w.setLayout(grid)
- w2 = QWidget()
- vbox = QVBoxLayout()
- vbox.addWidget(w)
- vbox.addStretch(1)
- w2.setLayout(vbox)
-
def entry_changed( is_fee ):
- self.funds_error = False
if self.amount_e.is_shortcut:
self.amount_e.is_shortcut = False
sendable = self.get_sendable_balance()
# there is only one output because we are completely spending inputs
- inputs, total, fee = self.wallet.choose_tx_inputs( sendable, 0, 1, self.get_payment_sources())
+ 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.read_amount(str(self.amount_e.text()))
- fee = self.read_amount(str(self.fee_e.text()))
+ 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, self.get_payment_sources())
- 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") + ')'
self.fee_e.textChanged.connect(lambda: entry_changed(True) )
run_hook('create_send_tab', grid)
- return w2
+ return w
+
+ def from_list_delete(self, item):
+ i = self.from_list.indexOfTopLevelItem(item)
+ self.pay_from.pop(i)
+ self.redraw_from_list()
+ def from_list_menu(self, position):
+ item = self.from_list.itemAt(position)
+ menu = QMenu()
+ menu.addAction(_("Remove"), lambda: self.from_list_delete(item))
+ menu.exec_(self.from_list.viewport().mapToGlobal(position))
- def set_pay_from(self, l):
- self.pay_from = l
+ def set_pay_from(self, domain = None):
+ self.pay_from = [] if domain == [] else self.wallet.get_unspent_coins(domain)
+ self.redraw_from_list()
+
+ def redraw_from_list(self):
self.from_list.clear()
self.from_label.setHidden(len(self.pay_from) == 0)
self.from_list.setHidden(len(self.pay_from) == 0)
- for addr in self.pay_from:
- c, u = self.wallet.get_addr_balance(addr)
- balance = self.format_amount(c + u)
- self.from_list.addTopLevelItem(QTreeWidgetItem( [addr, balance] ))
+ def format(x):
+ h = x.get('prevout_hash')
+ return h[0:8] + '...' + h[-8:] + ":%d"%x.get('prevout_n') + u'\t' + "%s"%x.get('address')
+
+ for item in self.pay_from:
+ self.from_list.addTopLevelItem(QTreeWidgetItem( [format(item), self.format_amount(item['value']) ]))
def update_completions(self):
l = []
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() )
- r = unicode( self.payto_e.text() )
- r = r.strip()
- # label or alias, with address in brackets
- m = re.match('(.*?)\s*\<([1-9A-HJ-NP-Za-km-z]{26,})\>', r)
- to_address = m.group(2) if m else r
+ if self.payment_request:
+ outputs = self.payment_request.get_outputs()
+ else:
+ outputs = self.payto_e.get_outputs()
- if not is_valid(to_address):
- QMessageBox.warning(self, _('Error'), _('Invalid Bitcoin Address') + ':\n' + to_address, _('OK'))
+ if not outputs:
+ QMessageBox.warning(self, _('Error'), _('No outputs'), _('OK'))
return
- try:
- amount = self.read_amount(unicode( self.amount_e.text()))
- except Exception:
- QMessageBox.warning(self, _('Error'), _('Invalid Amount'), _('OK'))
- return
- try:
- fee = self.read_amount(unicode( self.fee_e.text()))
- except Exception:
+ 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 amount is None:
+ QMessageBox.warning(self, _('Error'), _('Invalid Amount'), _('OK'))
+ return
+
+ amount = sum(map(lambda x:x[2], outputs))
+
+ 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:
- if not self.question(_("send %(amount)s to %(address)s?")%{ 'amount' : self.format_amount(amount) + ' '+ self.base_unit(), 'address' : to_address}):
+ 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
confirm_fee = self.config.get('confirm_fee', 100000)
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(to_address, amount, fee, label)
+ coins = self.get_coins()
+ return outputs, fee, label, coins
- def waiting_dialog(self, message):
- d = QDialog(self)
- d.setWindowTitle('Please wait')
- l = QLabel(message)
- vbox = QVBoxLayout(d)
- vbox.addWidget(l)
- d.show()
- return d
+ 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, to_address, amount, fee, label, password):
+ def send_tx(self, outputs, fee, label, coins, password):
+ self.send_button.setDisabled(True)
# first, create an unsigned tx
- domain = self.get_payment_sources()
- outputs = [(to_address, amount)]
try:
- tx = self.wallet.make_unsigned_transaction(outputs, fee, None, domain)
+ tx = self.wallet.make_unsigned_transaction(outputs, fee, None, coins = coins)
tx.error = None
except Exception as e:
traceback.print_exc(file=sys.stdout)
self.show_message(str(e))
+ self.send_button.setDisabled(False)
return
# call hook to see if plugin needs gui interaction
# 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)
- self.signed_tx_data = (tx, fee, label)
- self.emit(SIGNAL('send_tx2'))
- self.tx_wait_dialog = self.waiting_dialog('Signing..')
- threading.Thread(target=sign_thread).start()
-
- # add recipient to addressbook
- if to_address not in self.wallet.addressbook and not self.wallet.is_mine(to_address):
- self.wallet.addressbook.append(to_address)
-
-
- def send_tx2(self):
- tx, fee, label = self.signed_tx_data
- self.tx_wait_dialog.accept()
-
- if tx.error:
- self.show_message(tx.error)
- return
+ 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
- if tx.requires_fee(self.wallet.verifier) and fee < MIN_RELAY_TX_FEE:
- QMessageBox.warning(self, _('Error'), _("This transaction requires a higher fee, or it will not be propagated by the network."), _('OK'))
- return
+ def sign_done(tx):
+ if tx.error:
+ self.show_message(tx.error)
+ self.send_button.setDisabled(False)
+ return
+ if tx.requires_fee(self.wallet.verifier) and fee < MIN_RELAY_TX_FEE:
+ QMessageBox.warning(self, _('Error'), _("This transaction requires a higher fee, or it will not be propagated by the network."), _('OK'))
+ self.send_button.setDisabled(False)
+ return
+ if label:
+ self.wallet.set_label(tx.hash(), label)
- if label:
- self.wallet.set_label(tx.hash(), label)
+ if not tx.is_complete() or self.config.get('show_before_broadcast'):
+ self.show_transaction(tx)
+ self.do_clear()
+ self.send_button.setDisabled(False)
+ return
- if not tx.is_complete():
- self.show_transaction(tx)
- return
+ 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()
+
+
+
+ def broadcast_transaction(self, tx):
- # broadcast the tx
def broadcast_thread():
- self.tx_broadcast_result = self.wallet.sendtx(tx)
- self.emit(SIGNAL('send_tx3'))
- self.tx_broadcast_dialog = self.waiting_dialog('Broadcasting..')
- threading.Thread(target=broadcast_thread).start()
+ 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):
+ if status:
+ QMessageBox.information(self, '', _('Payment sent.') + '\n' + msg, _('OK'))
+ self.do_clear()
+ else:
+ QMessageBox.warning(self, _('Error'), msg, _('OK'))
+ self.send_button.setDisabled(False)
+ self.waiting_dialog = WaitingDialog(self, 'Broadcasting..', broadcast_thread, broadcast_done)
+ self.waiting_dialog.start()
- def send_tx3(self):
- self.tx_broadcast_dialog.accept()
- status, msg = self.tx_broadcast_result
- if status:
- QMessageBox.information(self, '', _('Payment sent.') + '\n' + msg, _('OK'))
- self.do_clear()
- self.update_contacts_tab()
+
+
+ def prepare_for_payment_request(self):
+ self.tabs.setCurrentIndex(1)
+ self.payto_e.is_pr = True
+ for e in [self.payto_e, self.amount_e, self.message_e]:
+ e.setFrozen(True)
+ for h in [self.payto_help, self.amount_help, self.message_help]:
+ h.hide()
+ self.payto_e.setText(_("please wait..."))
+ return True
+
+ def payment_request_ok(self):
+ pr = self.payment_request
+ pr_id = pr.get_id()
+ 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:
- QMessageBox.warning(self, _('Error'), msg, _('OK'))
+ 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(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.get_memo())
+ def payment_request_error(self):
+ self.do_clear()
+ self.show_message(self.payment_request.error)
+ self.payment_request = None
- def set_url(self, url):
- try:
- address, amount, label, message, signature, identity, url = util.parse_url(url)
- except Exception:
- QMessageBox.warning(self, _('Error'), _('Invalid bitcoin URL'), _('OK'))
+ def pay_from_URI(self,URI):
+ if not URI:
return
-
+ address, amount, label, message, request_url = util.parse_URI(URI)
try:
- if amount and self.base_unit() == 'mBTC': amount = str( 1000* Decimal(amount))
- elif amount: amount = str(Decimal(amount))
- except Exception:
- amount = "0.0"
- QMessageBox.warning(self, _('Error'), _('Invalid Amount'), _('OK'))
+ 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
- if self.mini:
- self.mini.set_payment_fields(address, amount)
+ self.tabs.setCurrentIndex(1)
- 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)
+ 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
- run_hook('set_url', url, self.show_message, self.question)
+ 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.tabs.setCurrentIndex(1)
- label = self.wallet.labels.get(address)
- m_addr = label + ' <'+ address +'>' if label else address
- self.payto_e.setText(m_addr)
+ self.pr_thread = threading.Thread(target=payment_request).start()
+ self.prepare_for_payment_request()
- self.message_e.setText(message)
- if amount:
- self.amount_e.setText(amount)
- if identity:
- self.set_frozen(self.payto_e,True)
- self.set_frozen(self.amount_e,True)
- self.set_frozen(self.message_e,True)
- self.payto_sig.setText( ' '+_('The bitcoin URI was signed by')+' ' + identity )
- else:
- self.payto_sig.setVisible(False)
def do_clear(self):
+ self.payto_e.is_pr = False
self.payto_sig.setVisible(False)
for e in [self.payto_e, self.message_e, self.amount_e, self.fee_e]:
e.setText('')
- self.set_frozen(e,False)
+ e.setFrozen(False)
+
+ for h in [self.payto_help, self.amount_help, self.message_help]:
+ h.show()
+ self.payto_help.set_alt(None)
self.set_pay_from([])
self.update_status()
- def set_frozen(self,entry,frozen):
- if frozen:
- entry.setReadOnly(True)
- entry.setFrame(False)
- palette = QPalette()
- palette.setColor(entry.backgroundRole(), QColor('lightgray'))
- entry.setPalette(palette)
- else:
- entry.setReadOnly(False)
- entry.setFrame(True)
- palette = QPalette()
- palette.setColor(entry.backgroundRole(), QColor('white'))
- entry.setPalette(palette)
def set_addrs_frozen(self,addrs,freeze):
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()
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
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):
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 = 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_invoice_menu)
+ self.invoices_list = l
+ return w
+
+ def update_invoices_tab(self):
+ invoices = self.wallet.storage.get('invoices', {})
+ l = self.invoices_list
+ l.clear()
+ 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))
+
+
+
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):
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)
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]
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 self.wallet.seed:
+ 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))
- if addr in self.wallet.imported_keys:
+ 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))
if any(addr not in self.wallet.frozen_addresses for addr in addrs):
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):
- return sum(sum(self.wallet.get_addr_balance(a)) for a in self.get_payment_sources())
+ return sum(map(lambda x:x['value'], self.get_coins()))
- def get_payment_sources(self):
+ def get_coins(self):
if self.pay_from:
return self.pay_from
else:
- return self.wallet.get_account_addresses(self.current_account)
+ domain = self.wallet.get_account_addresses(self.current_account)
+ for i in self.wallet.frozen_addresses:
+ if i in domain: domain.remove(i)
+ return self.wallet.get_unspent_coins(domain)
def send_from_addresses(self, addrs):
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 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()
+
- 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 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))
- c, u = self.wallet.get_addr_balance(address)
- balance = self.format_amount(c + u)
- item.setData(2,0,balance)
- 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()
- l.setColumnHidden(2, False)
- l.setColumnHidden(3, False)
- for i,width in enumerate(self.column_widths['receive']):
- l.setColumnWidth(i, width)
+ accounts = self.wallet.get_accounts()
if self.current_account is None:
- account_items = self.wallet.accounts.items()
- elif self.current_account != -1:
- account_items = [(self.current_account, self.wallet.accounts.get(self.current_account))]
+ account_items = sorted(accounts.items())
else:
- account_items = []
+ account_items = [(self.current_account, accounts.get(self.current_account))]
+
for k, account in account_items:
- name = self.wallet.get_account_name(k)
- c,u = self.wallet.get_account_balance(k)
- account_item = QTreeWidgetItem( [ name, '', self.format_amount(c+u), ''] )
- l.addTopLevelItem(account_item)
- account_item.setExpanded(self.accounts_expanded.get(k, True))
- account_item.setData(0, 32, k)
-
- if not self.wallet.is_seeded(k):
- icon = QIcon(":icons/key.png")
- account_item.setIcon(0, icon)
-
- for is_change in ([0,1]):
- name = _("Receiving") if not is_change else _("Change")
- seq_item = QTreeWidgetItem( [ name, '', '', '', ''] )
- account_item.addChild(seq_item)
+
+ if len(accounts) > 1:
+ name = self.wallet.get_account_name(k)
+ c,u = self.wallet.get_account_balance(k)
+ account_item = QTreeWidgetItem( [ name, '', self.format_amount(c+u), ''] )
+ l.addTopLevelItem(account_item)
+ account_item.setExpanded(self.accounts_expanded.get(k, True))
+ account_item.setData(0, 32, k)
+ else:
+ account_item = l
+
+ sequences = [0,1] if account.has_change() else [0]
+ for is_change in sequences:
+ if len(sequences) > 1:
+ name = _("Receiving") if not is_change else _("Change")
+ seq_item = QTreeWidgetItem( [ name, '', '', '', ''] )
+ account_item.addChild(seq_item)
+ if not is_change:
+ seq_item.setExpanded(True)
+ else:
+ seq_item = account_item
+
used_item = QTreeWidgetItem( [ _("Used"), '', '', '', ''] )
used_flag = False
- if not is_change: seq_item.setExpanded(True)
-
- is_red = False
- gap = 0
-
- for address in account.get_addresses(is_change):
- h = self.wallet.history.get(address,[])
-
- if h == []:
- gap += 1
- if gap > self.wallet.gap_limit:
- is_red = True
- else:
- gap = 0
+ addr_list = account.get_addresses(is_change)
+ for address in addr_list:
+ num, is_used = self.wallet.is_used(address)
+ label = self.wallet.labels.get(address,'')
c, u = self.wallet.get_addr_balance(address)
- num_tx = '*' if h == ['*'] else "%d"%len(h)
- item = QTreeWidgetItem( [ address, '', '', num_tx] )
- self.update_receive_item(item)
- if is_red:
- item.setBackgroundColor(1, QColor('red'))
- if len(h) > 0 and c == -u:
+ 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:
seq_item.addChild(item)
-
- for k, addr in self.wallet.get_pending_accounts():
- name = self.wallet.labels.get(k,'')
- account_item = QTreeWidgetItem( [ name + " [ "+_('pending account')+" ]", '', '', ''] )
- self.update_receive_item(item)
- l.addTopLevelItem(account_item)
- account_item.setExpanded(True)
- account_item.setData(0, 32, k)
- item = QTreeWidgetItem( [ addr, '', '', '', ''] )
- account_item.addChild(item)
- self.update_receive_item(item)
-
-
- if self.wallet.imported_keys and (self.current_account is None or self.current_account == -1):
- c,u = self.wallet.get_imported_balance()
- account_item = QTreeWidgetItem( [ _('Imported'), '', self.format_amount(c+u), ''] )
- l.addTopLevelItem(account_item)
- account_item.setExpanded(True)
- for address in self.wallet.imported_keys.keys():
- item = QTreeWidgetItem( [ address, '', '', ''] )
- self.update_receive_item(item)
- account_item.addChild(item)
-
-
# we use column 1 because column 0 may be hidden
l.setCurrentItem(l.topLevelItem(0),1)
l.setCurrentItem(l.topLevelItem(0))
-
def create_console_tab(self):
from console import Console
self.console = console = Console()
self.current_account = k
self.update_history_tab()
self.update_status()
+ self.update_address_tab()
self.update_receive_tab()
def create_status_bar(self):
def update_buttons_on_seed(self):
- if not self.wallet.is_watching_only():
+ if self.wallet.has_seed():
self.seed_button.show()
+ else:
+ self.seed_button.hide()
+
+ if not self.wallet.is_watching_only():
self.password_button.show()
self.send_button.setText(_("Send"))
else:
self.password_button.hide()
- self.seed_button.hide()
self.send_button.setText(_("Create unsigned transaction"))
name = str(e.text())
if not name: return
- self.wallet.create_pending_account('1of1', name, password)
- self.update_receive_tab()
- self.tabs.setCurrentIndex(2)
-
-
-
- def show_master_public_key_old(self):
- dialog = QDialog(self)
- dialog.setModal(1)
- dialog.setWindowTitle(_("Master Public Key"))
-
- main_text = QTextEdit()
- main_text.setText(self.wallet.get_master_public_key())
- main_text.setReadOnly(True)
- main_text.setMaximumHeight(170)
- qrw = QRCodeWidget(self.wallet.get_master_public_key())
-
- ok_button = QPushButton(_("OK"))
- ok_button.setDefault(True)
- ok_button.clicked.connect(dialog.accept)
-
- main_layout = QGridLayout()
- main_layout.addWidget(QLabel(_('Your Master Public Key is:')), 0, 0, 1, 2)
-
- main_layout.addWidget(main_text, 1, 0)
- main_layout.addWidget(qrw, 1, 1 )
+ self.wallet.create_pending_account(name, password)
+ self.update_address_tab()
+ self.tabs.setCurrentIndex(3)
- vbox = QVBoxLayout()
- vbox.addLayout(main_layout)
- vbox.addLayout(close_button(dialog))
- dialog.setLayout(vbox)
- dialog.exec_()
- def show_master_public_key(self):
- if self.wallet.seed_version == 4:
- self.show_master_public_key_old()
- return
+ def show_master_public_keys(self):
dialog = QDialog(self)
dialog.setModal(1)
dialog.setWindowTitle(_("Master Public Keys"))
- mpk_text = QTextEdit()
- mpk_text.setReadOnly(True)
- mpk_text.setMaximumHeight(170)
- mpk_qrw = QRCodeWidget()
-
main_layout = QGridLayout()
-
- main_layout.addWidget(QLabel(_('Key')), 1, 0)
- main_layout.addWidget(mpk_text, 1, 1)
- main_layout.addWidget(mpk_qrw, 1, 2)
-
- def update(key):
- xpub = self.wallet.master_public_keys[str(key)]
- mpk_text.setText(xpub)
- mpk_qrw.set_addr(xpub)
- mpk_qrw.update_qr()
-
- key_selector = QComboBox()
- keys = sorted(self.wallet.master_public_keys.keys())
- key_selector.addItems(keys)
-
- main_layout.addWidget(QLabel(_('Derivation:')), 0, 0)
- main_layout.addWidget(key_selector, 0, 1)
- dialog.connect(key_selector,SIGNAL("activated(QString)"),update)
-
- update(keys[0])
+ mpk_dict = self.wallet.get_master_public_keys()
+ i = 0
+ for key, value in mpk_dict.items():
+ main_layout.addWidget(QLabel(key), i, 0)
+ mpk_text = QTextEdit()
+ mpk_text.setReadOnly(True)
+ mpk_text.setMaximumHeight(170)
+ mpk_text.setText(value)
+ main_layout.addWidget(mpk_text, i + 1, 0)
+ i += 2
vbox = QVBoxLayout()
vbox.addLayout(main_layout)
@protected
def show_seed_dialog(self, password):
- if self.wallet.is_watching_only():
- QMessageBox.information(self, _('Message'), _('This is a watching-only wallet'), _('OK'))
+ if not self.wallet.has_seed():
+ QMessageBox.information(self, _('Message'), _('This wallet has no seed'), _('OK'))
return
- if self.wallet.seed:
- try:
- mnemonic = self.wallet.get_mnemonic(password)
- except Exception:
- QMessageBox.warning(self, _('Error'), _('Incorrect Password'), _('OK'))
- return
- from seed_dialog import SeedDialog
- d = SeedDialog(self, mnemonic, self.wallet.imported_keys)
- d.exec_()
- else:
- l = {}
- for k in self.wallet.master_private_keys.keys():
- pk = self.wallet.get_master_private_key(k, password)
- l[k] = pk
- from seed_dialog import PrivateKeysDialog
- d = PrivateKeysDialog(self,l)
- d.exec_()
-
-
+ try:
+ mnemonic = self.wallet.get_mnemonic(password)
+ except Exception:
+ QMessageBox.warning(self, _('Error'), _('Incorrect Password'), _('OK'))
+ return
+ from seed_dialog import SeedDialog
+ d = SeedDialog(self, mnemonic, self.wallet.has_imported_keys())
+ d.exec_()
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_()
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_()
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_()
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)
def show_message(self, msg):
QMessageBox.information(self, _('Message'), msg, _('OK'))
- def password_dialog(self ):
+ def password_dialog(self, msg=None):
d = QDialog(self)
d.setModal(1)
d.setWindowTitle(_("Enter Password"))
pw.setEchoMode(2)
vbox = QVBoxLayout()
- msg = _('Please enter your password')
+ if not msg:
+ msg = _('Please enter your password')
vbox.addWidget(QLabel(msg))
grid = QGridLayout()
"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()
- assert "complete" in tx_dict.keys()
- tx = Transaction(tx_dict["hex"], tx_dict["complete"])
- if not tx_dict["complete"]:
- assert "input_info" in tx_dict.keys()
- 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:
- pass
+ traceback.print_exc(file=sys.stdout)
+ 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):
@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"))
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:
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
@protected
- def do_export_privkeys(self, password):
- if not self.wallet.seed:
- self.show_message(_("This wallet has no seed"))
+ def export_privkeys_dialog(self, password):
+ if self.wallet.is_watching_only():
+ self.show_message(_("This is a watching-only wallet"))
return
- self.show_message("%s\n%s\n%s" % (_("WARNING: ALL your private keys are secret."), _("Exposing a single private key can compromise your entire wallet!"), _("In particular, DO NOT use 'redeem private key' services proposed by third parties.")))
+ d = QDialog(self)
+ d.setWindowTitle(_('Private keys'))
+ d.setMinimumSize(850, 300)
+ vbox = QVBoxLayout(d)
+
+ msg = "%s\n%s\n%s" % (_("WARNING: ALL your private keys are secret."),
+ _("Exposing a single private key can compromise your entire wallet!"),
+ _("In particular, DO NOT use 'redeem private key' services proposed by third parties."))
+ vbox.addWidget(QLabel(msg))
- try:
- select_export = _('Select file to export your private keys to')
- fileName = self.getSaveFileName(select_export, 'electrum-private-keys.csv', "*.csv")
- if fileName:
- with open(fileName, "w+") as csvfile:
- transaction = csv.writer(csvfile)
- transaction.writerow(["address", "private_key"])
+ e = QTextEdit()
+ e.setReadOnly(True)
+ vbox.addWidget(e)
- addresses = self.wallet.addresses(True)
+ defaultname = 'electrum-private-keys.csv'
+ select_msg = _('Select file to export your private keys to')
+ hbox, filename_e, csv_button = filename_field(self, self.config, defaultname, select_msg)
+ vbox.addLayout(hbox)
- for addr in addresses:
- pk = "".join(self.wallet.get_private_key(addr, password))
- transaction.writerow(["%34s"%addr,pk])
+ h, b = ok_cancel_buttons2(d, _('Export'))
+ b.setEnabled(False)
+ vbox.addLayout(h)
+
+ private_keys = {}
+ addresses = self.wallet.addresses(True)
+ done = False
+ def privkeys_thread():
+ for addr in addresses:
+ time.sleep(0.1)
+ if done:
+ break
+ private_keys[addr] = "\n".join(self.wallet.get_private_key(addr, password))
+ d.emit(SIGNAL('computing_privkeys'))
+ d.emit(SIGNAL('show_privkeys'))
+
+ def show_privkeys():
+ s = "\n".join( map( lambda x: x[0] + "\t"+ x[1], private_keys.items()))
+ e.setText(s)
+ b.setEnabled(True)
+
+ d.connect(d, QtCore.SIGNAL('computing_privkeys'), lambda: e.setText("Please wait... %d/%d"%(len(private_keys),len(addresses))))
+ d.connect(d, QtCore.SIGNAL('show_privkeys'), show_privkeys)
+ threading.Thread(target=privkeys_thread).start()
- self.show_message(_("Private keys exported."))
+ if not d.exec_():
+ done = True
+ return
+
+ filename = filename_e.text()
+ if not filename:
+ return
+ try:
+ self.do_export_privkeys(filename, private_keys, csv_button.isChecked())
except (IOError, os.error), reason:
export_error_label = _("Electrum was unable to produce a private key-export.")
QMessageBox.critical(None, _("Unable to create csv"), export_error_label + "\n" + str(reason))
except Exception as e:
- self.show_message(str(e))
- return
+ self.show_message(str(e))
+ return
+
+ self.show_message(_("Private keys exported."))
+
+
+ def do_export_privkeys(self, fileName, pklist, is_csv):
+ with open(fileName, "w+") as f:
+ if is_csv:
+ transaction = csv.writer(f)
+ transaction.writerow(["address", "private_key"])
+ for addr, pk in pklist.items():
+ transaction.writerow(["%34s"%addr,pk])
+ else:
+ import json
+ f.write(json.dumps(pklist, indent = 4))
def do_import_labels(self):
QMessageBox.critical(None, _("Unable to export labels"), _("Electrum was unable to export your labels.")+"\n" + str(reason))
- def do_export_history(self):
- wallet = self.wallet
- select_export = _('Select file to export your wallet transactions to')
- fileName = QFileDialog.getSaveFileName(QWidget(), select_export, os.path.expanduser('~/electrum-history.csv'), "*.csv")
- if not fileName:
+ def export_history_dialog(self):
+
+ d = QDialog(self)
+ d.setWindowTitle(_('Export History'))
+ d.setMinimumSize(400, 200)
+ vbox = QVBoxLayout(d)
+
+ defaultname = os.path.expanduser('~/electrum-history.csv')
+ select_msg = _('Select file to export your wallet transactions to')
+
+ hbox, filename_e, csv_button = filename_field(self, self.config, defaultname, select_msg)
+ vbox.addLayout(hbox)
+
+ vbox.addStretch(1)
+
+ h, b = ok_cancel_buttons2(d, _('Export'))
+ vbox.addLayout(h)
+ if not d.exec_():
+ return
+
+ filename = filename_e.text()
+ if not filename:
return
try:
- with open(fileName, "w+") as csvfile:
- transaction = csv.writer(csvfile)
+ self.do_export_history(self.wallet, filename, csv_button.isChecked())
+ except (IOError, os.error), reason:
+ export_error_label = _("Electrum was unable to produce a transaction export.")
+ QMessageBox.critical(self, _("Unable to export history"), export_error_label + "\n" + str(reason))
+ return
+
+ QMessageBox.information(self,_("History exported"), _("Your wallet history has been successfully exported."))
+
+
+ def do_export_history(self, wallet, fileName, is_csv):
+ history = wallet.get_tx_history()
+ lines = []
+ for item in history:
+ tx_hash, confirmations, is_mine, value, fee, balance, timestamp = item
+ if confirmations:
+ if timestamp is not None:
+ try:
+ time_string = datetime.datetime.fromtimestamp(timestamp).isoformat(' ')[:-3]
+ except [RuntimeError, TypeError, NameError] as reason:
+ time_string = "unknown"
+ pass
+ else:
+ time_string = "unknown"
+ else:
+ time_string = "pending"
+
+ if value is not None:
+ value_string = format_satoshis(value, True)
+ else:
+ value_string = '--'
+
+ if fee is not None:
+ fee_string = format_satoshis(fee, True)
+ else:
+ fee_string = '0'
+
+ if tx_hash:
+ label, is_default_label = wallet.get_label(tx_hash)
+ label = label.encode('utf-8')
+ else:
+ label = ""
+
+ balance_string = format_satoshis(balance, False)
+ if is_csv:
+ lines.append([tx_hash, label, confirmations, value_string, fee_string, balance_string, time_string])
+ else:
+ lines.append({'txid':tx_hash, 'date':"%16s"%time_string, 'label':label, 'value':value_string})
+
+ with open(fileName, "w+") as f:
+ if is_csv:
+ transaction = csv.writer(f)
transaction.writerow(["transaction_hash","label", "confirmations", "value", "fee", "balance", "timestamp"])
- for item in wallet.get_tx_history():
- tx_hash, confirmations, is_mine, value, fee, balance, timestamp = item
- if confirmations:
- if timestamp is not None:
- try:
- time_string = datetime.datetime.fromtimestamp(timestamp).isoformat(' ')[:-3]
- except [RuntimeError, TypeError, NameError] as reason:
- time_string = "unknown"
- pass
- else:
- time_string = "unknown"
- else:
- time_string = "pending"
+ for line in lines:
+ transaction.writerow(line)
+ else:
+ import json
+ f.write(json.dumps(lines, indent = 4))
- if value is not None:
- value_string = format_satoshis(value, True)
- else:
- value_string = '--'
- if fee is not None:
- fee_string = format_satoshis(fee, True)
- else:
- fee_string = '0'
+ def sweep_key_dialog(self):
+ d = QDialog(self)
+ d.setWindowTitle(_('Sweep private keys'))
+ d.setMinimumSize(600, 300)
- if tx_hash:
- label, is_default_label = wallet.get_label(tx_hash)
- label = label.encode('utf-8')
- else:
- label = ""
+ vbox = QVBoxLayout(d)
+ vbox.addWidget(QLabel(_("Enter private keys")))
- balance_string = format_satoshis(balance, False)
- transaction.writerow([tx_hash, label, confirmations, value_string, fee_string, balance_string, time_string])
- QMessageBox.information(None,_("CSV Export created"), _("Your CSV export has been successfully created."))
+ keys_e = QTextEdit()
+ keys_e.setTabChangesFocus(True)
+ vbox.addWidget(keys_e)
- except (IOError, os.error), reason:
- export_error_label = _("Electrum was unable to produce a transaction export.")
- QMessageBox.critical(None,_("Unable to create csv"), export_error_label + "\n" + str(reason))
+ h, address_e = address_field(self.wallet.addresses())
+ vbox.addLayout(h)
+ vbox.addStretch(1)
+ hbox, button = ok_cancel_buttons2(d, _('Sweep'))
+ vbox.addLayout(hbox)
+ button.setEnabled(False)
+
+ def get_address():
+ addr = str(address_e.text())
+ if bitcoin.is_address(addr):
+ return addr
+
+ def get_pk():
+ pk = str(keys_e.toPlainText()).strip()
+ if Wallet.is_private_key(pk):
+ return pk.split()
+
+ f = lambda: button.setEnabled(get_address() is not None and get_pk() is not None)
+ keys_e.textChanged.connect(f)
+ address_e.textChanged.connect(f)
+ if not d.exec_():
+ return
+
+ fee = self.wallet.fee
+ tx = Transaction.sweep(get_pk(), self.network, get_address(), fee)
+ self.show_transaction(tx)
@protected
def do_import_privkey(self, password):
- if not self.wallet.imported_keys:
+ if not self.wallet.has_imported_keys():
r = QMessageBox.question(None, _('Warning'), '<b>'+_('Warning') +':\n</b><br/>'+ _('Imported keys are not recoverable from seed.') + ' ' \
+ _('If you ever need to restore your wallet from its seed, these keys will be lost.') + '<p>' \
+ _('Are you sure you understand what you are doing?'), 3, 4)
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()
fee_label = QLabel(_('Transaction fee') + ':')
grid.addWidget(fee_label, 2, 0)
- fee_e = AmountEdit(self.base_unit)
- 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()
grid.addWidget(HelpButton(_('Using change addresses makes it more difficult for other people to track your transactions.')+' '), 4, 2)
if not self.config.is_modifiable('use_change'): usechange_cb.setEnabled(False)
- grid.setRowStretch(5,1)
+ block_explorers = ['Blockchain.info', 'Blockr.io', 'Insight.is']
+ block_ex_label = QLabel(_('Online Block Explorer') + ':')
+ grid.addWidget(block_ex_label, 5, 0)
+ block_ex_combo = QComboBox()
+ block_ex_combo.addItems(block_explorers)
+ block_ex_combo.setCurrentIndex(block_explorers.index(self.config.get('block_explorer', 'Blockchain.info')))
+ grid.addWidget(block_ex_combo, 5, 1)
+ grid.addWidget(HelpButton(_('Choose which online block explorer to use for functions that open a web browser')+' '), 5, 2)
+
+ show_tx = self.config.get('show_before_broadcast', False)
+ showtx_cb = QCheckBox(_('Show before broadcast'))
+ showtx_cb.setChecked(show_tx)
+ grid.addWidget(showtx_cb, 6, 0)
+ grid.addWidget(HelpButton(_('Display the details of your transactions before broadcasting it.')), 6, 2)
vbox.addLayout(grid)
+ vbox.addStretch(1)
vbox.addLayout(ok_cancel_buttons(d))
d.setLayout(vbox)
# run the dialog
if not d.exec_(): return
- fee = unicode(fee_e.text())
- try:
- fee = self.read_amount(fee)
- except Exception:
+ fee = fee_e.get_amount()
+ if fee is None:
QMessageBox.warning(self, _('Error'), _('Invalid value') +': %s'%fee, _('OK'))
return
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:
self.wallet.use_change = usechange_result
self.wallet.storage.put('use_change', self.wallet.use_change)
+ if showtx_cb.isChecked() != show_tx:
+ self.config.set_key('show_before_broadcast', not show_tx)
+
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()
self.config.set_key("language", lang_request, True)
need_restart = True
+ be_result = block_explorers[block_ex_combo.currentIndex()]
+ self.config.set_key('block_explorer', be_result, True)
+
run_hook('close_settings_dialog')
if need_restart:
def closeEvent(self, event):
self.tray.hide()
- g = self.geometry()
- self.config.set_key("winpos-qt", [g.left(),g.top(),g.width(),g.height()], True)
+ self.config.set_key("is_maximized", self.isMaximized())
+ if not self.isMaximized():
+ g = self.geometry()
+ self.config.set_key("winpos-qt", [g.left(),g.top(),g.width(),g.height()])
self.save_column_widths()
self.config.set_key("console-history", self.console.history[-50:], True)
self.wallet.storage.put('accounts_expanded', self.accounts_expanded)