from electrum import util, bitcoin, commands, Interface, Wallet
from electrum import SimpleConfig, Wallet, WalletStorage
-
-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'
+
+
+# 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 *
-
-
+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):
self.decimal_point = config.get('decimal_point', 5)
self.num_zeros = int(config.get('num_zeros',0))
+ self.invoices = {}
set_language(config.get('language'))
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)
self.console.showMessage(self.network.banner)
self.wallet = None
-
+ self.payment_request = None
def update_account_selector(self):
# account selector
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
self.update_buttons_on_seed()
self.update_console()
+ self.clear_receive_tab()
+ self.update_receive_tab()
run_hook('load_wallet', wallet)
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)
+ self.raw_transaction_menu = raw_transaction_menu
help_menu = menubar.addMenu(_("&Help"))
help_menu.addAction(_("&About"), self.show_about)
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):
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
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.clear_receive_tab)
+ 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 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.address_is_old(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)
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)
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([])
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(
+ _('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)
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)
def entry_changed( is_fee ):
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.fee_e.setAmount(fee)
return
amount = self.amount_e.get_amount()
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())
+ 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 ) )
+ self.fee_e.setAmount(fee)
if inputs:
palette = QPalette()
palette.setColor(self.amount_e.foregroundRole(), QColor('black'))
run_hook('create_send_tab', grid)
return w
+ def from_list_delete(self, item):
+ i = self.from_list.indexOfTopLevelItem(item)
+ self.pay_from.pop(i)
+ self.redraw_from_list()
- def set_pay_from(self, l):
- self.pay_from = l
+ 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, 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):
- label = unicode( self.message_e.text() )
+ def read_send_tab(self):
- if self.gui_object.payment_request:
- outputs = self.gui_object.payment_request.outputs
- amount = self.gui_object.payment_request.get_amount()
+ 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.payment_request:
+ outputs = self.payment_request.get_outputs()
else:
- 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 not is_valid(to_address):
- QMessageBox.warning(self, _('Error'), _('Invalid Bitcoin Address') + ':\n' + to_address, _('OK'))
+ outputs = self.payto_e.get_outputs()
+
+ if not outputs:
+ QMessageBox.warning(self, _('Error'), _('No outputs'), _('OK'))
+ return
+
+ for addr, x in outputs:
+ if addr is None or not bitcoin.is_address(addr):
+ QMessageBox.warning(self, _('Error'), _('Invalid Bitcoin Address'), _('OK'))
return
-
- try:
- amount = self.amount_e.get_amount()
- except Exception:
+ if x is None:
QMessageBox.warning(self, _('Error'), _('Invalid Amount'), _('OK'))
return
- outputs = [(to_address, amount)]
+ amount = sum(map(lambda x:x[1], 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:
- 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[0], 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(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
- domain = self.get_payment_sources()
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)
def sign_thread():
time.sleep(0.1)
keypairs = {}
- self.wallet.add_keypairs_from_wallet(tx, keypairs, password)
+ self.wallet.add_keypairs(tx, keypairs, password)
self.wallet.sign_transaction(tx, keypairs, password)
return tx, fee, label
if label:
self.wallet.set_label(tx.hash(), label)
- if not self.gui_object.payment_request:
- 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() or self.config.get('show_before_broadcast'):
+ self.show_transaction(tx)
+ self.do_clear()
+ self.send_button.setDisabled(False)
+ return
self.broadcast_transaction(tx)
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):
def prepare_for_payment_request(self):
- style = "QWidget { background-color:none;border:none;}"
self.tabs.setCurrentIndex(1)
+ self.payto_e.is_pr = True
for e in [self.payto_e, self.amount_e, self.message_e]:
- e.setReadOnly(True)
- e.setStyleSheet(style)
+ 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):
- self.payto_e.setText(self.gui_object.payment_request.domain)
- self.amount_e.setText(self.format_amount(self.gui_object.payment_request.get_amount()))
- self.message_e.setText(self.gui_object.payment_request.memo)
+ 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:
+ 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.gui_object.payment_request.error)
+ self.show_message(self.payment_request.error)
+ self.payment_request = None
+
+ 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)
- def set_send(self, address, amount, label, message):
+ 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
- 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)
+ 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)
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.setStyleSheet("")
+ 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 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))
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 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))
+
- def update_receive_item(self, item):
+ def update_address_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)
+ run_hook('update_address_item', address, item)
if not self.wallet.is_mine(address): return
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:
gap = 0
item = QTreeWidgetItem( [ address, '', '', "%d"%num] )
- self.update_receive_item(item)
+ self.update_address_item(item)
if is_red:
item.setBackgroundColor(1, QColor('red'))
self.current_account = k
self.update_history_tab()
self.update_status()
+ self.update_address_tab()
self.update_receive_tab()
def create_status_bar(self):
if not name: return
self.wallet.create_pending_account(name, password)
- self.update_receive_tab()
+ self.update_address_tab()
self.tabs.setCurrentIndex(2)
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_()
"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(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)
+ #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"))
@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"))
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.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)
# 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
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: