def create_proposal(self):
manager = self.parent.masternode_manager
try:
proposal = self.create_proposal_from_widgets()
except Exception as e:
return QMessageBox.critical(self, _('Error'), _(str(e)))
pw = None
if manager.wallet.use_encryption:
pw = self.parent.password_dialog(msg=_(
'Please enter your password to create a budget proposal.'))
if pw is None:
return
manager.add_proposal(proposal)
def sign_done(proposal, tx):
print_error('proposal tx sign done: %s' % proposal.proposal_name)
if tx:
label = _('Budget Proposal Tx: ') + proposal.proposal_name
self.parent.broadcast_transaction(tx, label)
self.parent.masternode_manager.save()
self.create_proposal_tx(proposal, pw, sign_done)
def toggle_passphrase(self):
if self.features.passphrase_protection:
self.msg = _("Confirm on your %s device to disable passphrases")
else:
self.msg = _("Confirm on your %s device to enable passphrases")
enabled = not self.features.passphrase_protection
self.apply_settings(use_passphrase=enabled)
def __init__(self, parent):
super(CharacterDialog, self).__init__(parent)
self.setWindowTitle(_("KeepKey Seed Recovery"))
self.character_pos = 0
self.word_pos = 0
self.loop = QEventLoop()
self.word_help = QLabel()
self.char_buttons = []
vbox = QVBoxLayout(self)
vbox.addWidget(WWLabel(CHARACTER_RECOVERY))
hbox = QHBoxLayout()
hbox.addWidget(self.word_help)
for i in range(4):
char_button = CharacterButton('*')
char_button.setMaximumWidth(36)
self.char_buttons.append(char_button)
hbox.addWidget(char_button)
self.accept_button = CharacterButton(_("Accept Word"))
self.accept_button.clicked.connect(partial(self.process_key, 32))
self.rejected.connect(partial(self.loop.exit, 1))
hbox.addWidget(self.accept_button)
hbox.addStretch(1)
vbox.addLayout(hbox)
self.finished_button = QPushButton(_("Seed Entered"))
self.cancel_button = QPushButton(_("Cancel"))
self.finished_button.clicked.connect(
partial(self.process_key, Qt.Key_Return))
self.cancel_button.clicked.connect(self.rejected)
buttons = Buttons(self.finished_button, self.cancel_button)
vbox.addSpacing(40)
vbox.addLayout(buttons)
self.refresh()
self.show()
def save_current_masternode(self, as_new=False):
"""Save the masternode that is being viewed.
If as_new is True, a new masternode will be created.
"""
delegate_privkey = str(self.masternode_editor.delegate_key_edit.text())
try:
self.manager.import_masternode_delegate(delegate_privkey)
delegate_pubkey = bitcoin.public_key_from_private_key(
delegate_privkey)
except Exception:
# Show an error if the private key is invalid and not an empty string.
if delegate_privkey:
QMessageBox.warning(
self, _('Warning'),
_('Ignoring invalid delegate private key.'))
delegate_pubkey = ''
alias = str(self.masternode_editor.alias_edit.text())
# Construct a new masternode.
if as_new:
kwargs = self.masternode_editor.get_masternode_args()
kwargs['delegate_key'] = delegate_pubkey
del kwargs['vin']
self.mapper.revert()
self.masternodes_widget.add_masternode(
MasternodeAnnounce(**kwargs))
else:
self.mapper.submit()
self.manager.save()
self.masternodes_widget.select_masternode(alias)
def create_layout(self):
self.masternodes_widget = MasternodesWidget(self.manager)
self.tabs = QTabWidget()
self.tabs.addTab(self.create_view_masternode_tab(),
_('View Masternode'))
self.tabs.addTab(self.create_collateral_tab(), _('Choose Collateral'))
self.tabs.addTab(self.create_sign_announce_tab(),
_('Activate Masternode'))
self.tabs.addTab(self.create_masternode_conf_tab(),
_('Masternode.conf'))
# Disabled until API is stable.
# self.tabs.addTab(self.create_vote_tab(), _('Vote'))
# Connect to the selection signal so we can update the widget mapper.
self.masternodes_widget.view.selectionModel().selectionChanged.connect(
self.on_view_selection_changed)
bottom_buttons = util.Buttons(util.CloseButton(self))
vbox = QVBoxLayout()
vbox.addWidget(QLabel(_('Masternodes:')))
vbox.addWidget(self.masternodes_widget, stretch=1)
vbox.addWidget(self.tabs)
vbox.addLayout(bottom_buttons)
self.setLayout(vbox)
def sign_announce(self, alias):
"""Sign an announce for alias. This is called by SignAnnounceWidget."""
pw = None
if self.manager.wallet.use_encryption:
pw = self.gui.password_dialog(msg=_(
'Please enter your password to activate masternode "%s".' %
alias))
if pw is None:
return
self.sign_announce_widget.sign_button.setEnabled(False)
def sign_thread():
return self.manager.sign_announce(alias, pw)
def on_sign_successful(mn):
self.print_msg('Successfully signed Masternode Announce.')
self.send_announce(alias)
# Proceed to broadcasting the announcement, or re-enable the button.
def on_sign_error(err):
self.print_error('Error signing MasternodeAnnounce:')
# Print traceback information to error log.
self.print_error(''.join(traceback.format_tb(err[2])))
self.print_error(''.join(
traceback.format_exception_only(err[0], err[1])))
self.sign_announce_widget.sign_button.setEnabled(True)
util.WaitingDialog(self, _('Signing Masternode Announce...'),
sign_thread, on_sign_successful, on_sign_error)
def task():
wallet.wait_until_synchronized()
if wallet.is_found():
msg = _("Recovery successful")
else:
msg = _("No transactions found for this seed")
self.emit(QtCore.SIGNAL('synchronized'), msg)
def update(self, proposals, main_window):
item = self.currentItem()
current_proposal = item.data(ProposalsModel.TXID,
Qt.UserRole).toString() if item else None
self.model.set_proposals(proposals)
self.clear()
row_count = self.model.rowCount()
if row_count < 1:
return
for r in range(row_count):
get_data = lambda col, row=r: self.model.data(
self.model.index(row, col))
name = _(str(get_data(ProposalsModel.NAME).toString()))
url = _(str(get_data(ProposalsModel.URL).toString()))
yes_count = str(get_data(ProposalsModel.YES_COUNT).toString())
no_count = str(get_data(ProposalsModel.NO_COUNT).toString())
start_block = str(get_data(ProposalsModel.START_BLOCK).toString())
end_block = str(get_data(ProposalsModel.END_BLOCK).toString())
amount = str(get_data(ProposalsModel.AMOUNT).toString())
address = str(get_data(ProposalsModel.ADDRESS).toString())
txid = str(get_data(ProposalsModel.TXID).toString())
display_txid = '%s...%s' % (txid[0:8], txid[-8:])
item = QTreeWidgetItem([
name, url, yes_count, no_count, start_block, end_block, amount,
address, display_txid
])
item.setFont(ProposalsModel.START_BLOCK,
QFont(util.MONOSPACE_FONT))
item.setFont(ProposalsModel.END_BLOCK, QFont(util.MONOSPACE_FONT))
item.setFont(ProposalsModel.ADDRESS, QFont(util.MONOSPACE_FONT))
item.setFont(ProposalsModel.TXID, QFont(util.MONOSPACE_FONT))
if name:
item.setData(ProposalsModel.NAME, Qt.UserRole, name)
if txid:
item.setData(ProposalsModel.TXID, Qt.UserRole, txid)
is_my_proposal = False
if main_window.masternode_manager.get_proposal(name) is not None:
is_my_proposal = True
if is_my_proposal:
item.setBackground(ProposalsModel.NAME,
QBrush(QColor(MY_PROPOSAL_COLOR)))
item.setToolTip(ProposalsModel.NAME,
_('You created this proposal.'))
is_my_address = main_window.wallet.is_mine(address)
if is_my_address:
item.setBackground(ProposalsModel.ADDRESS,
QBrush(QColor(MY_ADDRESS_COLOR)))
item.setToolTip(ProposalsModel.ADDRESS,
_('You own this address.'))
self.addTopLevelItem(item)
if current_proposal == name:
self.setCurrentItem(item)
def set_pin(self, remove):
if remove:
self.msg = _("Confirm on your %s device to disable PIN protection")
elif self.features.pin_protection:
self.msg = _("Confirm on your %s device to change your PIN")
else:
self.msg = _("Confirm on your %s device to set a PIN")
self.change_pin(remove)
def closeEvent(self, event):
if (self.prompt_if_unsaved and not self.saved and not self.question(
_('This transaction is not saved. Close anyway?'),
title=_("Warning"))):
event.ignore()
else:
event.accept()
dialogs.remove(self)
def add_cosigner_dialog(self, run_next, index, is_valid):
title = _("Add Cosigner") + " %d" % index
message = ' '.join([
_('Please enter the master public key (xpub) of your cosigner.'),
_('Enter their master private key (xprv) if you want to be able to sign for them.'
)
])
return self.text_input(title, message, is_valid)
def on_vote_successful(result):
errmsg, res = result
if res:
QMessageBox.information(self, _('Success'),
_('Successfully voted'))
else:
QMessageBox.critical(self, _('Error Voting'), _(errmsg))
self.proposals_widget.editor.vote_button.setEnabled(True)
def __init__(self, parent=None):
MyTreeWidget.__init__(self, parent, self.create_menu, [
_('Address'),
_('Label'),
_('Amount'),
_('Height'),
_('Output point')
], 1)
self.setSelectionMode(QAbstractItemView.ExtendedSelection)
def delete_current_masternode(self):
"""Delete the masternode that is being viewed."""
mn = self.selected_masternode()
if QMessageBox.question(
self, _('Delete'),
_('Do you want to remove the masternode configuration for') +
' %s?' % mn.alias, QMessageBox.Yes | QMessageBox.No,
QMessageBox.No) == QMessageBox.Yes:
self.masternodes_widget.remove_masternode(mn.alias)
self.masternodes_widget.view.selectRow(0)
def save(self):
name = 'signed_%s.txn' % (
self.tx.hash()[0:8]) if self.tx.is_complete() else 'unsigned.txn'
fileName = self.main_window.getSaveFileName(
_("Select where to save your signed transaction"), name, "*.txn")
if fileName:
with open(fileName, "w+") as f:
f.write(json.dumps(self.tx.as_dict(), indent=4) + '\n')
self.show_message(_("Transaction saved successfully"))
self.saved = True
def wipe_device():
wallet = window.wallet
if wallet and sum(wallet.get_balance()):
title = _("Confirm Device Wipe")
msg = _("Are you SURE you want to wipe the device?\n"
"Your wallet still has Desire in it!")
if not self.question(
msg, title=title, icon=QMessageBox.Critical):
return
invoke_client('wipe_device', unpair_after=True)
def show_xpub_dialog(self, xpub, run_next):
msg = ' '.join([
_("Here is your master public key."),
_("Please share it with your cosigners.")
])
vbox = QVBoxLayout()
layout = SeedLayout(xpub, title=msg, icon=False)
vbox.addLayout(layout.layout())
self.exec_layout(vbox, _('Master Public Key'))
return None
def restore_seed_dialog(self, run_next, test):
options = []
if self.opt_ext:
options.append('ext')
if self.opt_bip39:
options.append('bip39')
title = _('Enter Seed')
message = _(
'Please enter your seed phrase in order to restore your wallet.')
return self.seed_input(title, message, test, options)
def __init__(self, parent=None):
super(ProposalsModel, self).__init__(parent)
self.proposals = []
headers = [
{
Qt.DisplayRole: _('Name'),
},
{
Qt.DisplayRole: _('URL'),
},
{
Qt.DisplayRole: _('Yes Votes'),
},
{
Qt.DisplayRole: _('No Votes'),
},
{
Qt.DisplayRole: _('Start Block'),
},
{
Qt.DisplayRole: _('End Block'),
},
{
Qt.DisplayRole: _('Amount'),
},
{
Qt.DisplayRole: _('Address'),
},
{
Qt.DisplayRole: _('Fee Tx'),
},
]
for d in headers:
d[Qt.EditRole] = d[Qt.DisplayRole]
self.headers = headers
def __init__(self, parent=None):
super(ProposalsTreeWidget, self).__init__(parent, self.create_menu, [
_('Name'),
_('URL'),
_('Yes Votes'),
_('No Votes'),
_('Start Block'),
_('End Block'),
_('Amount'),
_('Address'),
_('Fee Tx')
], 0)
header = self.header()
header.setResizeMode(ProposalsModel.NAME, QHeaderView.ResizeToContents)
header.setResizeMode(ProposalsModel.URL, QHeaderView.Stretch)
header.setResizeMode(ProposalsModel.YES_COUNT,
QHeaderView.ResizeToContents)
header.setResizeMode(ProposalsModel.NO_COUNT,
QHeaderView.ResizeToContents)
header.setResizeMode(ProposalsModel.ADDRESS,
QHeaderView.ResizeToContents)
header.setResizeMode(ProposalsModel.TXID, QHeaderView.ResizeToContents)
self.model = ProposalsModel()
def confirm_seed_dialog(self, run_next, test):
self.app.clipboard().clear()
title = _('Confirm Seed')
message = ' '.join([
_('Your seed is important!'),
_('If you lose your seed, your money will be permanently lost.'),
_('To make sure that you have properly saved your seed, please retype it here.'
)
])
seed, is_bip39, is_ext = self.seed_input(title, message, test, None)
return seed
def __init__(self, main_widget, parent=None):
super(ProposalEditor, self).__init__(parent)
self.main_widget = main_widget
self.name_edit = QLineEdit()
self.url_edit = QLineEdit()
self.start_block_edit = QLineEdit()
self.end_block_edit = QLineEdit()
self.amount_edit = QLineEdit()
self.address_edit = QLineEdit()
self.txid_edit = QLineEdit()
for i in [
self.name_edit, self.url_edit, self.start_block_edit,
self.end_block_edit, self.amount_edit, self.address_edit,
self.txid_edit
]:
i.setReadOnly(True)
self.mapper = QDataWidgetMapper()
self.mapper.setModel(self.main_widget.proxy_model)
self.mapper.setSubmitPolicy(QDataWidgetMapper.ManualSubmit)
self.mapper.addMapping(self.name_edit, ProposalsModel.NAME)
self.mapper.addMapping(self.url_edit, ProposalsModel.URL)
self.mapper.addMapping(self.start_block_edit,
ProposalsModel.START_BLOCK)
self.mapper.addMapping(self.end_block_edit, ProposalsModel.END_BLOCK)
self.mapper.addMapping(self.amount_edit, ProposalsModel.AMOUNT)
self.mapper.addMapping(self.address_edit, ProposalsModel.ADDRESS)
self.mapper.addMapping(self.txid_edit, ProposalsModel.TXID)
block_hbox = QHBoxLayout()
block_hbox.addWidget(self.start_block_edit)
block_hbox.addWidget(QLabel(' - '))
block_hbox.addWidget(self.end_block_edit)
self.vote_combo = QComboBox()
self.vote_combo.addItem(_('Yes'))
self.vote_combo.addItem(_('No'))
self.vote_button = QPushButton(_('Vote'))
self.vote_button.clicked.connect(self.cast_vote)
vote_hbox = util.Buttons(self.vote_combo, self.vote_button)
form = QFormLayout()
form.addRow(_('Name:'), self.name_edit)
form.addRow(_('URL:'), self.url_edit)
form.addRow(_('Blocks:'), block_hbox)
form.addRow(_('Monthly Payment:'), self.amount_edit)
form.addRow(_('Payment Address:'), self.address_edit)
form.addRow(_('Fee TxID:'), self.txid_edit)
form.addRow(_('Vote:'), vote_hbox)
self.setLayout(form)
def backup_password_dialog(self):
msg = _("Enter the password used when the backup was created:")
while True:
password = self.handler.get_passphrase(msg, False)
if password is None:
return None
if len(password) < 4:
msg = _("Password must have at least 4 characters.\r\n\r\nEnter password:"******"Password must have less than 64 characters.\r\n\r\nEnter password:")
else:
return str(password)
def __init__(self, parent, seed, passphrase):
WindowModalDialog.__init__(self, parent,
('Electrum-DSR - ' + _('Seed')))
self.setMinimumWidth(400)
vbox = QVBoxLayout(self)
title = _("Your wallet generation seed is:")
slayout = SeedLayout(title=title,
seed=seed,
msg=True,
passphrase=passphrase)
vbox.addLayout(slayout)
vbox.addLayout(Buttons(CloseButton(self)))
def password_dialog(self, msg):
while True:
password = self.handler.get_passphrase(msg, False)
if password is None:
return False
if len(password) < 4:
msg = _("Password must have at least 4 characters.\r\n\r\nEnter password:"******"Password must have less than 64 characters.\r\n\r\nEnter password:")
else:
self.password = str(password)
return True
def callback_PinMatrixRequest(self, msg):
if msg.type == 2:
msg = _("Enter a new PIN for your %s:")
elif msg.type == 3:
msg = (_("Re-enter the new PIN for your %s.\n\n"
"NOTE: the positions of the numbers have changed!"))
else:
msg = _("Enter your current %s PIN:")
pin = self.handler.get_pin(msg % self.device)
if not pin:
return self.proto.Cancel()
return self.proto.PinMatrixAck(pin=pin)
def build_tray_menu(self):
# Avoid immediate GC of old menu when window closed via its action
self.old_menu = self.tray.contextMenu()
m = QMenu()
for window in self.windows:
submenu = m.addMenu(window.wallet.basename())
submenu.addAction(_("Show/Hide"), window.show_or_hide)
submenu.addAction(_("Close"), window.close)
m.addAction(_("Dark/Light"), self.toggle_tray_icon)
m.addSeparator()
m.addAction(_("Exit Electrum-DSR"), self.close)
self.tray.setContextMenu(m)
def __init__(self,
seed=None,
title=None,
icon=True,
msg=None,
options=None,
is_seed=None,
passphrase=None,
parent=None):
QVBoxLayout.__init__(self)
self.parent = parent
self.options = options
if title:
self.addWidget(WWLabel(title))
if seed:
self.seed_e = ShowQRTextEdit()
self.seed_e.setText(seed)
else:
self.seed_e = ScanQRTextEdit()
self.seed_e.setTabChangesFocus(True)
self.is_seed = is_seed
self.saved_is_seed = self.is_seed
self.seed_e.textChanged.connect(self.on_edit)
self.seed_e.setMaximumHeight(75)
hbox = QHBoxLayout()
if icon:
logo = QLabel()
logo.setPixmap(QPixmap(":icons/seed.png").scaledToWidth(64))
logo.setMaximumWidth(60)
hbox.addWidget(logo)
hbox.addWidget(self.seed_e)
self.addLayout(hbox)
hbox = QHBoxLayout()
hbox.addStretch(1)
self.seed_type_label = QLabel('')
hbox.addWidget(self.seed_type_label)
if options:
opt_button = EnterButton(_('Options'), self.seed_options)
hbox.addWidget(opt_button)
self.addLayout(hbox)
if passphrase:
hbox = QHBoxLayout()
passphrase_e = QLineEdit()
passphrase_e.setText(passphrase)
passphrase_e.setReadOnly(True)
hbox.addWidget(QLabel(_("Your seed extension is") + ':'))
hbox.addWidget(passphrase_e)
self.addLayout(hbox)
self.addStretch(1)
if msg:
msg = seed_warning_msg(seed)
self.addWidget(WWLabel(msg))
def callback_PassphraseRequest(self, req):
if self.creating_wallet:
msg = _("Enter a passphrase to generate this wallet. Each time "
"you use this wallet your %s will prompt you for the "
"passphrase. If you forget the passphrase you cannot "
"access the Desire in the wallet.") % self.device
else:
msg = _("Enter the passphrase to unlock this wallet:")
passphrase = self.handler.get_passphrase(msg, self.creating_wallet)
if passphrase is None:
return self.proto.Cancel()
passphrase = bip39_normalize_passphrase(passphrase)
return self.proto.PassphraseAck(passphrase=passphrase)
def create_menu(self, position):
item = self.currentItem()
if not item:
return
is_server = not bool(item.data(0, Qt.UserRole).toInt()[0])
menu = QMenu()
if is_server:
server = unicode(item.data(1, Qt.UserRole).toString())
menu.addAction(_("Use as server"), lambda: self.parent.follow_server(server))
else:
index = item.data(1, Qt.UserRole).toInt()[0]
menu.addAction(_("Follow this branch"), lambda: self.parent.follow_branch(index))
menu.exec_(self.viewport().mapToGlobal(position))
