def do_send(self):
if self.screen.is_pr:
if self.payment_request.has_expired():
self.app.show_error(_('Payment request has expired'))
return
outputs = self.payment_request.get_outputs()
else:
address = str(self.screen.address)
if not address:
self.app.show_error(
_('Recipient not specified.') + ' ' +
_('Please scan a AXE address or a payment request'))
return
if not bitcoin.is_address(address):
self.app.show_error(_('Invalid AXE Address') + ':\n' + address)
return
try:
amount = self.app.get_amount(self.screen.amount)
except:
self.app.show_error(
_('Invalid amount') + ':\n' + self.screen.amount)
return
outputs = [TxOutput(bitcoin.TYPE_ADDRESS, address, amount)]
message = self.screen.message
amount = sum(map(lambda x: x[2], outputs))
self._do_send(amount, message, outputs)
def update(self):
format_amount = self.app.format_amount_and_units
tx_details = self.wallet.get_tx_info(self.tx)
tx_mined_status = tx_details.tx_mined_status
exp_n = tx_details.mempool_depth_bytes
amount, fee = tx_details.amount, tx_details.fee
self.status_str = tx_details.status
self.description = tx_details.label
self.can_broadcast = tx_details.can_broadcast
self.tx_hash = tx_details.txid or ''
if tx_mined_status.timestamp:
self.date_label = _('Date')
self.date_str = datetime.fromtimestamp(
tx_mined_status.timestamp).isoformat(' ')[:-3]
elif exp_n:
self.date_label = _('Mempool depth')
self.date_str = _('{} from tip').format('%.2f MB' %
(exp_n / 1000000))
else:
self.date_label = ''
self.date_str = ''
if amount is None:
self.amount_str = _("Transaction unrelated to your wallet")
elif amount > 0:
self.is_mine = False
self.amount_str = format_amount(amount)
else:
self.is_mine = True
self.amount_str = format_amount(-amount)
self.fee_str = format_amount(fee) if fee is not None else _('unknown')
self.can_sign = self.wallet.can_sign(self.tx)
self.ids.output_list.update(self.tx.get_outputs_for_UI())
self.is_local_tx = tx_mined_status.height == TX_HEIGHT_LOCAL
self.update_action_button()
def update_action_button(self):
action_button = self.ids.action_button
options = (
ActionButtonOption(text=_('Sign'), func=lambda btn: self.do_sign(), enabled=self.can_sign),
ActionButtonOption(text=_('Broadcast'), func=lambda btn: self.do_broadcast(), enabled=self.can_broadcast),
ActionButtonOption(text=_('Remove'), func=lambda btn: self.remove_local_tx(), enabled=self.is_local_tx),
)
num_options = sum(map(lambda o: bool(o.enabled), options))
# if no options available, hide button
if num_options == 0:
action_button.disabled = True
action_button.opacity = 0
return
action_button.disabled = False
action_button.opacity = 1
if num_options == 1:
# only one option, button will correspond to that
for option in options:
if option.enabled:
action_button.text = option.text
self._action_button_fn = option.func
else:
# multiple options. button opens dropdown which has one sub-button for each
dropdown = DropDown()
action_button.text = _('Options')
self._action_button_fn = dropdown.open
for option in options:
if option.enabled:
btn = Button(text=option.text, size_hint_y=None, height='48dp')
btn.bind(on_release=option.func)
dropdown.add_widget(btn)
def privatesend_txt(self, is_ps=None):
if is_ps is None:
is_ps = self.is_ps
if is_ps:
return _('PrivateSend')
else:
return _('Regular Transaction')
def update(self, *args, **kwargs):
self.vbox.clear_widgets()
self.vbox.add_widget(AxePeerCard(_('Peer'),
_('User Agent'),
is_title=True))
for peer, ua in self.dn_dlg.peers:
self.vbox.add_widget(AxePeerCard(peer, ua))
def update(self):
self.menu_actions = [(_('Use'), self.do_use),
(_('Details'), self.do_view)]
wallet = self.app.wallet
if self.show_change == 0:
_list = wallet.get_receiving_addresses()
elif self.show_change == 1:
_list = wallet.get_change_addresses()
else:
_list = wallet.get_addresses()
search = self.message
container = self.ids.search_container
n = 0
cards = []
for address in _list:
label = wallet.labels.get(address, '')
balance = sum(wallet.get_addr_balance(address))
is_used_and_empty = wallet.is_used(address) and balance == 0
if self.show_used == 1 and (balance or is_used_and_empty):
continue
if self.show_used == 2 and balance == 0:
continue
if self.show_used == 3 and not is_used_and_empty:
continue
card = self.get_card(address, balance, is_used_and_empty, label)
if search and not self.ext_search(card, search):
continue
cards.append(card)
n += 1
container.data = cards
if not n:
self.app.show_error('No address matching your search')
def selection_changed(self, nodes):
w = self.app.wallet
psman = w.psman
self.hide_menu()
self.coins_selected = [self.utxos[i] for i in nodes]
if not self.coins_selected:
self.selected_str = ''
self.ids.clear_btn.disabled = True
return
else:
self.selected_str = f' ({len(self.coins_selected)})'
self.ids.clear_btn.disabled = False
coins = self.coins_selected
if len(coins) != 1:
return
r = coins[0]['ps_rounds']
if r is None:
return
if r == PSCoinRounds.OTHER or r >= 0:
coin_value = coins[0]['value']
if coin_value >= psman.min_new_denoms_from_coins_val:
cmenu = [(_('Create New Denoms'), self.create_new_denoms)]
elif coin_value >= psman.min_new_collateral_from_coins_val:
cmenu = [(_('Create New Collateral'),
self.create_new_collateral)]
self.context_menu = ContextMenu(None, cmenu)
self.cmbox.add_widget(self.context_menu)
def get_card(self, addr, balance, is_used, label):
ci = {}
ci['screen'] = self
ci['address'] = addr
ci['memo'] = label
ci['amount'] = self.app.format_amount_and_units(balance)
ci['status'] = _('Used') if is_used else _(
'Funded') if balance > 0 else _('Unused')
return ci
def update(self):
self.menu_actions = [(_('Use'), self.do_use),
(_('Details'), self.do_view)]
wallet = self.app.wallet
psman = wallet.psman
if self.show_change == 0:
if self.show_ps_ks == 0: # Main
_list = wallet.get_receiving_addresses()
elif self.show_ps_ks == 1: # PS Keystore
_list = psman.get_receiving_addresses()
else: # All
_list = (wallet.get_receiving_addresses() +
psman.get_receiving_addresses())
elif self.show_change == 1:
if self.show_ps_ks == 0: # Main
_list = wallet.get_change_addresses()
elif self.show_ps_ks == 1: # PS Keystore
_list = psman.get_change_addresses()
else: # All
_list = (wallet.get_change_addresses() +
psman.get_change_addresses())
else:
if self.show_ps_ks == 0: # Main
_list = wallet.get_addresses()
elif self.show_ps_ks == 1: # PS Keystore
_list = psman.get_addresses()
else: # All
_list = (wallet.get_addresses() + psman.get_addresses())
search = self.message
container = self.ids.search_container
n = 0
cards = []
ps_addrs = wallet.db.get_ps_addresses()
for address in _list:
if self.show_ps == 0: # Regular
if address in ps_addrs:
continue
elif self.show_ps == 1: # PrivateSend
if address not in ps_addrs:
continue
label = wallet.labels.get(address, '')
balance = sum(wallet.get_addr_balance(address))
is_used_and_empty = wallet.is_used(address) and balance == 0
if self.show_used == 1 and (balance or is_used_and_empty):
continue
if self.show_used == 2 and balance == 0:
continue
if self.show_used == 3 and not is_used_and_empty:
continue
card = self.get_card(address, balance, is_used_and_empty, label)
if search and not self.ext_search(card, search):
continue
cards.append(card)
n += 1
container.data = cards
if not n:
self.app.show_error('No address matching your search')
def update(self):
self.menu_actions = [(_('Show'), self.do_show),
(_('Delete'), self.do_delete)]
requests_list = self.ids.requests_container
requests_list.clear_widgets()
_list = self.app.wallet.get_sorted_requests(self.app.electrum_config)
for pr in _list:
ci = self.get_card(pr)
requests_list.add_widget(ci)
def do_copy(self):
uri = self.get_URI()
if not uri:
return
if self.screen.amount == '':
self.app._clipboard.copy(self.screen.address)
self.app.show_info(_('Address copied to clipboard'))
else:
self.app._clipboard.copy(uri)
self.app.show_info(_('Request copied to clipboard'))
def send_report(self):
try:
response = BaseCrashReporter.send_report(self, "/crash.json").json()
except requests.exceptions.RequestException:
self.show_popup(_('Unable to send report'), _("Please check your network connection."))
else:
self.show_popup(_('Report sent'), response["text"])
if response["location"]:
self.open_url(response["location"])
self.dismiss()
def set_address_status(self, addr):
if self.app.wallet.is_used(addr):
self.screen.status = _('This address has already been used.'
' For better privacy, do not reuse it'
' for new payments.')
elif addr in self.app.wallet.db.get_ps_reserved():
self.screen.status = _('This address has been reserved for'
' PrivateSend use. For better privacy,'
' do not use it for new payments.')
else:
self.screen.status = ''
def on_text(self, new_val):
if not new_val:
self.err.text = _('Missing value')
self.err.subs_val = self.min_val
return
new_val = int(new_val)
if new_val < self.min_val:
self.err.text = _('Value too small')
self.err.subs_val = self.min_val
elif new_val > self.max_val:
self.err.text = _('Value too large')
self.err.subs_val = self.max_val
else:
self.err.text = ''
self.value = new_val
def send_report(self):
try:
loop = self.main_window.network.asyncio_loop
proxy = self.main_window.network.proxy
response = json.loads(
BaseCrashReporter.send_report(self, loop, proxy,
"/crash.json"))
except (ValueError, ClientError):
self.show_popup(_('Unable to send report'),
_("Please check your network connection."))
else:
self.show_popup(_('Report sent'), response["text"])
if response["location"]:
self.open_url(response["location"])
self.dismiss()
def get_card(self, tx_hash, tx_mined_status, value, balance):
status, status_str = self.app.wallet.get_tx_status(
tx_hash, tx_mined_status)
icon = "atlas://electrum_axe/gui/kivy/theming/light/" + TX_ICONS[status]
label = self.app.wallet.get_label(tx_hash) if tx_hash else _(
'Pruned transaction outputs')
ri = {}
ri['screen'] = self
ri['tx_hash'] = tx_hash
ri['icon'] = icon
ri['date'] = status_str
ri['message'] = label
ri['confirmations'] = tx_mined_status.conf
if value is not None:
ri['is_mine'] = value < 0
if value < 0: value = -value
ri['amount'] = self.app.format_amount_and_units(value)
if self.app.fiat_unit:
fx = self.app.fx
fiat_value = value / Decimal(
bitcoin.COIN) * self.app.wallet.price_at_timestamp(
tx_hash, fx.timestamp_rate)
fiat_value = Fiat(fiat_value, fx.ccy)
ri['quote_text'] = str(fiat_value)
return ri
def get_card(self, tx_hash, tx_type, tx_mined_status,
value, balance, islock, label, group_txid, group_icn):
status, status_str = self.app.wallet.get_tx_status(tx_hash,
tx_mined_status,
islock)
if label is None:
label = (self.app.wallet.get_label(tx_hash) if tx_hash
else _('Pruned transaction outputs'))
ri = {}
ri['screen'] = self
ri['tx_hash'] = tx_hash
ri['tx_type'] = SPEC_TX_NAMES.get(tx_type, str(tx_type))
ri['icon'] = self.atlas_path + TX_ICONS[status]
ri['group_icn'] = group_icn
ri['group_txid'] = group_txid
ri['date'] = status_str
ri['message'] = label
ri['confirmations'] = tx_mined_status.conf
if value is not None:
ri['is_mine'] = value < 0
if value < 0: value = - value
ri['amount'] = self.app.format_amount_and_units(value)
if self.app.fiat_unit:
fx = self.app.fx
fiat_value = value / Decimal(bitcoin.COIN) * self.app.wallet.price_at_timestamp(tx_hash, fx.timestamp_rate)
fiat_value = Fiat(fiat_value, fx.ccy)
ri['quote_text'] = fiat_value.to_ui_string()
return ri
def update(self):
if not self.screen.address:
self.get_new_address()
else:
status = self.app.wallet.get_request_status(self.screen.address)
self.screen.status = _(
'Payment received') if status == PR_PAID else ''
def show_qr(self):
from electrum_axe.bitcoin import base_encode, bfh
raw_tx = str(self.tx)
text = bfh(raw_tx)
text = base_encode(text, base=43)
self.app.qr_dialog(_("Raw Transaction"),
text,
text_for_clipboard=raw_tx)
def fx_status(self):
fx = self.app.fx
if fx.is_enabled():
source = fx.exchange.name()
ccy = fx.get_currency()
return '%s [%s]' % (ccy, source)
else:
return _('None')
def unit_dialog(self, item, dt):
if self._unit_dialog is None:
def cb(text):
self.app._set_bu(text)
item.bu = self.app.base_unit
self._unit_dialog = ChoiceDialog(_('Denomination'), base_units_list,
self.app.base_unit, cb, keep_choice_order=True)
self._unit_dialog.open()
def _do_send(self, amount, message, outputs, is_ps=False):
# make unsigned transaction
config = self.app.electrum_config
wallet = self.app.wallet
mix_rounds = None if not is_ps else wallet.psman.mix_rounds
include_ps = (mix_rounds is None)
coins = wallet.get_spendable_coins(None, config, include_ps=include_ps,
min_rounds=mix_rounds)
try:
tx = wallet.make_unsigned_transaction(coins, outputs, config, None,
min_rounds=mix_rounds)
except NotEnoughFunds:
self.app.show_error(_("Not enough funds"))
return
except Exception as e:
traceback.print_exc(file=sys.stdout)
self.app.show_error(str(e))
return
fee = tx.get_fee()
msg = [
_("Amount to be sent") + ": " + self.app.format_amount_and_units(amount),
_("Mining fee") + ": " + self.app.format_amount_and_units(fee),
]
x_fee = run_hook('get_tx_extra_fee', self.app.wallet, tx)
if x_fee:
x_fee_address, x_fee_amount = x_fee
msg.append(_("Additional fees") + ": " + self.app.format_amount_and_units(x_fee_amount))
feerate_warning = simple_config.FEERATE_WARNING_HIGH_FEE
if fee > feerate_warning * tx.estimated_size() / 1000:
msg.append(_('Warning') + ': ' + _("The fee for this transaction seems unusually high."))
msg.append(_("Enter your PIN code to proceed"))
self.app.protected('\n'.join(msg), self.send_tx, (tx, message))
def _do_send(self, amount, message, outputs):
# make unsigned transaction
config = self.app.electrum_config
coins = self.app.wallet.get_spendable_coins(None, config)
try:
tx = self.app.wallet.make_unsigned_transaction(
coins, outputs, config, None)
except NotEnoughFunds:
self.app.show_error(_("Not enough funds"))
return
except Exception as e:
traceback.print_exc(file=sys.stdout)
self.app.show_error(str(e))
return
fee = tx.get_fee()
msg = [
_("Amount to be sent") + ": " +
self.app.format_amount_and_units(amount),
_("Mining fee") + ": " + self.app.format_amount_and_units(fee),
]
x_fee = run_hook('get_tx_extra_fee', self.app.wallet, tx)
if x_fee:
x_fee_address, x_fee_amount = x_fee
msg.append(
_("Additional fees") + ": " +
self.app.format_amount_and_units(x_fee_amount))
if fee >= config.get('confirm_fee', 10000):
msg.append(
_('Warning') + ': ' +
_("The fee for this transaction seems unusually high."))
msg.append(_("Enter your PIN code to proceed"))
self.app.protected('\n'.join(msg), self.send_tx, (tx, message))
def label_dialog(self, data):
from .dialogs.label_dialog import LabelDialog
key = data['tx_hash']
text = self.app.wallet.get_label(key)
def callback(text):
self.app.wallet.set_label(key, text)
self.update()
d = LabelDialog(_('Enter Transaction Label'), text, callback)
d.open()
def remove_local_tx(self):
txid = self.tx.txid()
to_delete = {txid}
to_delete |= self.wallet.get_depending_transactions(txid)
question = _("Are you sure you want to remove this transaction?")
if len(to_delete) > 1:
question = (_("Are you sure you want to remove this transaction and {} child transactions?")
.format(len(to_delete) - 1))
def on_prompt(b):
if b:
for tx in to_delete:
self.wallet.remove_transaction(tx)
self.wallet.storage.write()
self.app._trigger_update_wallet() # FIXME private...
self.dismiss()
d = Question(question, on_prompt)
d.open()
def language_dialog(self, item, dt):
if self._language_dialog is None:
l = self.config.get('language', 'en_UK')
def cb(key):
self.config.set_key("language", key, True)
item.lang = self.get_language_name()
self.app.language = key
self._language_dialog = ChoiceDialog(_('Language'), languages, l, cb)
self._language_dialog.open()
def do_delete(self, obj):
from .question import Question
def cb(result):
if result:
self.app.wallet.invoices.remove(obj.key)
self.hide_menu()
self.update()
d = Question(_('Delete invoice?'), cb)
d.open()
def coinselect_dialog(self, item, dt):
if self._coinselect_dialog is None:
choosers = sorted(coinchooser.COIN_CHOOSERS.keys())
chooser_name = coinchooser.get_name(self.config)
def cb(text):
self.config.set_key('coin_chooser', text)
item.status = text
self._coinselect_dialog = ChoiceDialog(_('Coin selection'), choosers, chooser_name, cb)
self._coinselect_dialog.open()
def on_currency(self, ccy):
b = (ccy != _('None'))
self.fx.set_enabled(b)
if b:
if ccy != self.fx.get_currency():
self.fx.set_currency(ccy)
self.app.fiat_unit = ccy
else:
self.app.is_fiat = False
Clock.schedule_once(lambda dt: self.add_exchanges())
def ps_dialog(self):
from .dialogs.checkbox_dialog import CheckBoxDialog
def ps_dialog_cb(key):
self.is_ps = key
if self.is_ps:
w = self.app.wallet
psman = w.psman
denoms_by_vals = psman.calc_denoms_by_values()
if denoms_by_vals:
if not psman.check_enough_sm_denoms(denoms_by_vals):
psman.postpone_notification('ps-not-enough-sm-denoms',
w, denoms_by_vals)
self.screen.ps_txt = self.privatesend_txt()
d = CheckBoxDialog(_('PrivateSend'),
_('Send coins as a PrivateSend transaction'),
self.is_ps, ps_dialog_cb)
d.open()