Esempio n. 1
0
    def scan_qr(self, on_complete):
        if platform != 'android':
            return
        from jnius import autoclass
        from android import activity
        PythonActivity = autoclass('org.kivy.android.PythonActivity')
        Intent = autoclass('android.content.Intent')
        intent = Intent("com.google.zxing.client.android.SCAN")
        intent.putExtra("SCAN_MODE", "QR_CODE_MODE")

        def on_qr_result(requestCode, resultCode, intent):
            if requestCode == 0:
                if resultCode == -1:  # RESULT_OK:
                    contents = intent.getStringExtra("SCAN_RESULT")
                    if intent.getStringExtra(
                            "SCAN_RESULT_FORMAT") == 'QR_CODE':
                        on_complete(contents)
                    else:
                        self.show_error(
                            "wrong format " +
                            intent.getStringExtra("SCAN_RESULT_FORMAT"))

        activity.bind(on_activity_result=on_qr_result)
        try:
            PythonActivity.mActivity.startActivityForResult(intent, 0)
        except:
            self.show_error(
                _('Could not start Barcode Scanner.') + ' ' +
                _('Please install the Barcode Scanner app from ZXing'))
Esempio n. 2
0
 def do_new(self):
     addr = self.get_new_address()
     if not addr:
         self.app.show_info(_('Please use the existing requests first.'))
     else:
         self.save_request()
         self.app.show_info(_('New request added to your list.'))
Esempio n. 3
0
 def change_password(self, cb):
     if self.wallet.has_password():
         self.protected(
             _("Changing PIN code.") + '\n' + _("Enter your current PIN:"),
             self._change_password, (cb, ))
     else:
         self._change_password(cb, None)
Esempio n. 4
0
    def update(self):
        format_amount = self.app.format_amount_and_units
        tx_hash, self.status_str, self.description, self.can_broadcast, self.can_rbf, amount, fee, height, conf, timestamp, exp_n = self.wallet.get_tx_info(
            self.tx)
        self.tx_hash = tx_hash or ''
        if timestamp:
            self.date_str = datetime.fromtimestamp(timestamp).isoformat(
                ' ')[:-3]
        elif exp_n:
            self.date_str = _('Within %d blocks') % exp_n if exp_n > 0 else _(
                'unknown (low fee)')
        else:
            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.outputs())
Esempio n. 5
0
 def __init__(self, wizard, **kwargs):
     super(RestoreSeedDialog, self).__init__(wizard, **kwargs)
     self._test = kwargs['test']
     from electrum_khc.mnemonic import Mnemonic
     from electrum_khc.old_mnemonic import words as old_wordlist
     self.words = set(Mnemonic('en').wordlist).union(set(old_wordlist))
     self.ids.text_input_seed.text = test_seed if is_test else ''
     self.message = _('Please type your seed phrase using the virtual keyboard.')
     self.title = _('Enter Seed')
     self.ext = False
Esempio n. 6
0
 def _show_seed(self, label, password):
     if self.wallet.has_password() and password is None:
         return
     keystore = self.wallet.keystore
     try:
         seed = keystore.get_seed(password)
         passphrase = keystore.get_passphrase(password)
     except:
         self.show_error("Invalid PIN")
         return
     label.text = _('Seed') + ':\n' + seed
     if passphrase:
         label.text += '\n\n' + _('Passphrase') + ': ' + passphrase
Esempio n. 7
0
    def get_card(self, req):
        address = req['address']
        timestamp = req.get('time', 0)
        amount = req.get('amount')
        expiration = req.get('exp', None)
        status = req.get('status')
        signature = req.get('sig')

        ci = self.cards.get(address)
        if ci is None:
            ci = Factory.RequestItem()
            ci.screen = self
            ci.address = address
            self.cards[address] = ci

        ci.memo = self.app.wallet.get_label(address)
        if amount:
            status = req.get('status')
            ci.status = request_text[status]
        else:
            received = self.app.wallet.get_addr_received(address)
            ci.status = self.app.format_amount_and_units(amount)
        ci.icon = pr_icon[status]
        ci.amount = self.app.format_amount_and_units(amount) if amount else _(
            'No Amount')
        ci.date = format_time(timestamp)
        return ci
Esempio n. 8
0
 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.keys(), self.app.base_unit, cb)
     self._unit_dialog.open()
Esempio n. 9
0
 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 ''
Esempio n. 10
0
    def new_wallet(self, app, dirname):
        def cb(text):
            if text:
                app.load_wallet_by_name(os.path.join(dirname, text))

        d = LabelDialog(_('Enter wallet name'), '', cb)
        d.open()
Esempio n. 11
0
 def get_card(self, tx_hash, height, conf, timestamp, value, balance):
     status, status_str = self.app.wallet.get_tx_status(
         tx_hash, height, conf, timestamp)
     icon = "atlas://gui/kivy/theming/light/" + TX_ICONS[status]
     label = self.app.wallet.get_label(tx_hash) if tx_hash else _(
         'Pruned transaction outputs')
     date = timestamp_to_datetime(timestamp)
     ri = self.cards.get(tx_hash)
     if ri is None:
         ri = Factory.HistoryItem()
         ri.screen = self
         ri.tx_hash = tx_hash
         self.cards[tx_hash] = ri
     ri.icon = icon
     ri.date = status_str
     ri.message = label
     ri.value = value or 0
     ri.amount = self.app.format_amount(value,
                                        True) if value is not None else '--'
     ri.confirmations = conf
     if self.app.fiat_unit and date:
         rate = self.app.fx.history_rate(date)
         if rate:
             s = self.app.fx.value_str(value, rate)
             ri.quote_text = '' if s is None else s + ' ' + self.app.fiat_unit
     return ri
Esempio n. 12
0
 def _sign_tx(self, tx, password, on_success, on_failure):
     try:
         self.wallet.sign_transaction(tx, password)
     except InvalidPassword:
         Clock.schedule_once(lambda dt: on_failure(_("Invalid PIN")))
         return
     Clock.schedule_once(lambda dt: on_success(tx))
Esempio n. 13
0
 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
     Clock.schedule_once(lambda dt: self.add_exchanges())
Esempio n. 14
0
 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')
Esempio n. 15
0
 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()
Esempio n. 16
0
    def description_dialog(self, screen):
        from uix.dialogs.label_dialog import LabelDialog
        text = screen.message

        def callback(text):
            screen.message = text

        d = LabelDialog(_('Enter description'), text, callback)
        d.open()
Esempio n. 17
0
 def on_keyboard(self, instance, key, keycode, codepoint, modifiers):
     if key == 27 and self.is_exit is False:
         self.is_exit = True
         self.show_info(_('Press again to exit'))
         return True
     # override settings button
     if key in (319, 282):  #f1/settings button on android
         #self.gui.main_gui.toggle_settings(self)
         return True
Esempio n. 18
0
 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()
Esempio n. 19
0
    def do_delete(self, obj):
        from dialogs.question import Question

        def cb(result):
            if result:
                self.app.wallet.invoices.remove(obj.key)
                self.app.update_tab('invoices')

        d = Question(_('Delete invoice?'), cb)
        d.open()
Esempio n. 20
0
 def on_ref_label(self, label, touch):
     if label.touched:
         label.touched = False
         self.qr_dialog(label.name, label.data, True)
     else:
         label.touched = True
         self._clipboard.copy(label.data)
         Clock.schedule_once(lambda dt: self.show_info(
             _('Text copied to clipboard.\nTap again to display it as QR code.'
               )))
Esempio n. 21
0
    def show_info_bubble(self,
                         text=_('Hello World'),
                         pos=None,
                         duration=0,
                         arrow_pos='bottom_mid',
                         width=None,
                         icon='',
                         modal=False,
                         exit=False):
        '''Method to show a Information Bubble

        .. parameters::
            text: Message to be displayed
            pos: position for the bubble
            duration: duration the bubble remains on screen. 0 = click to hide
            width: width of the Bubble
            arrow_pos: arrow position for the bubble
        '''
        info_bubble = self.info_bubble
        if not info_bubble:
            info_bubble = self.info_bubble = Factory.InfoBubble()

        win = Window
        if info_bubble.parent:
            win.remove_widget(info_bubble if not info_bubble.modal else
                              info_bubble._modal_view)

        if not arrow_pos:
            info_bubble.show_arrow = False
        else:
            info_bubble.show_arrow = True
            info_bubble.arrow_pos = arrow_pos
        img = info_bubble.ids.img
        if text == 'texture':
            # icon holds a texture not a source image
            # display the texture in full screen
            text = ''
            img.texture = icon
            info_bubble.fs = True
            info_bubble.show_arrow = False
            img.allow_stretch = True
            info_bubble.dim_background = True
            info_bubble.background_image = 'atlas://gui/kivy/theming/light/card'
        else:
            info_bubble.fs = False
            info_bubble.icon = icon
            #if img.texture and img._coreimage:
            #    img.reload()
            img.allow_stretch = False
            info_bubble.dim_background = False
            info_bubble.background_image = 'atlas://data/images/defaulttheme/bubble'
        info_bubble.message = text
        if not pos:
            pos = (win.center[0], win.center[1] - (info_bubble.height / 2))
        info_bubble.show(pos, duration, width, modal=modal, exit=exit)
Esempio n. 22
0
    def do_delete(self, obj):
        from dialogs.question import Question

        def cb(result):
            if result:
                self.app.wallet.remove_payment_request(
                    obj.address, self.app.electrum_config)
                self.update()

        d = Question(_('Delete request?'), cb)
        d.open()
Esempio n. 23
0
 def on_complete(ok, msg):
     if ok:
         self.show_info(_('Payment sent.'))
         if self.send_screen:
             self.send_screen.do_clear()
         if pr:
             self.wallet.invoices.set_paid(pr, tx.txid())
             self.wallet.invoices.save()
             self.update_tab('invoices')
     else:
         self.show_error(msg)
Esempio n. 24
0
    def broadcast(self, tx, pr=None):
        def on_complete(ok, msg):
            if ok:
                self.show_info(_('Payment sent.'))
                if self.send_screen:
                    self.send_screen.do_clear()
                if pr:
                    self.wallet.invoices.set_paid(pr, tx.txid())
                    self.wallet.invoices.save()
                    self.update_tab('invoices')
            else:
                self.show_error(msg)

        if self.network and self.network.is_connected():
            self.show_info(_('Sending'))
            threading.Thread(target=self._broadcast_thread,
                             args=(tx, on_complete)).start()
        else:
            self.show_info(
                _('Cannot broadcast transaction') + ':\n' + _('Not connected'))
Esempio n. 25
0
    def label_dialog(self, obj):
        from dialogs.label_dialog import LabelDialog
        key = obj.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()
Esempio n. 26
0
 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 KHcoin address or a payment request'))
             return
         if not bitcoin.is_address(address):
             self.app.show_error(
                 _('Invalid KHcoin 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 = [(bitcoin.TYPE_ADDRESS, address, amount)]
     message = unicode(self.screen.message)
     amount = sum(map(lambda x: x[2], outputs))
     if self.app.electrum_config.get('use_rbf'):
         from dialogs.question import Question
         d = Question(_('Should this transaction be replaceable?'),
                      lambda b: self._do_send(amount, message, outputs, b))
         d.open()
     else:
         self._do_send(amount, message, outputs, False)
Esempio n. 27
0
 def _do_send(self, amount, message, outputs, rbf):
     # 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
     if rbf:
         tx.set_rbf(True)
     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),
     ]
     if fee >= config.get('confirm_fee', 1000000):
         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))
Esempio n. 28
0
 def _change_password(self, cb, old_password):
     if self.wallet.has_password():
         if old_password is None:
             return
         try:
             self.wallet.check_password(old_password)
         except InvalidPassword:
             self.show_error("Invalid PIN")
             return
     self.password_dialog(_('Enter new PIN'), self._change_password2, (
         cb,
         old_password,
     ))
Esempio n. 29
0
    def __init__(self, obj, action_list):
        Bubble.__init__(self)
        self.obj = obj
        for k, v in action_list:
            l = MenuItem()
            l.text = _(k)

            def func(f=v):
                Clock.schedule_once(lambda dt: self.hide(), 0.1)
                Clock.schedule_once(lambda dt: f(obj), 0.15)

            l.on_release = func
            self.ids.buttons.add_widget(l)
Esempio n. 30
0
    def choose_blockchain_dialog(self, dt):
        from uix.dialogs.choice_dialog import ChoiceDialog
        chains = self.network.get_blockchains()

        def cb(name):
            for index, b in self.network.blockchains.items():
                if name == self.network.get_blockchain_name(b):
                    self.network.follow_chain(index)
                    #self.block

        names = [self.network.blockchains[b].get_name() for b in chains]
        if len(names) > 1:
            ChoiceDialog(_('Choose your chain'), names, '', cb).open()