1060 lines
39 KiB
Python
1060 lines
39 KiB
Python
###############################################################################
|
|
#
|
|
# The MIT License (MIT)
|
|
#
|
|
# Copyright (c) Crossbar.io Technologies GmbH
|
|
#
|
|
# Permission is hereby granted, free of charge, to any person obtaining a copy
|
|
# of this software and associated documentation files (the "Software"), to deal
|
|
# in the Software without restriction, including without limitation the rights
|
|
# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
|
# copies of the Software, and to permit persons to whom the Software is
|
|
# furnished to do so, subject to the following conditions:
|
|
#
|
|
# The above copyright notice and this permission notice shall be included in
|
|
# all copies or substantial portions of the Software.
|
|
#
|
|
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
|
# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
|
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
|
# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
|
|
# THE SOFTWARE.
|
|
#
|
|
###############################################################################
|
|
|
|
import os
|
|
import argparse
|
|
import uuid
|
|
import binascii
|
|
import random
|
|
import pkg_resources
|
|
from pprint import pprint
|
|
from time import time_ns
|
|
|
|
import gi
|
|
|
|
gi.require_version("Gtk", "3.0")
|
|
from gi.repository import Gtk
|
|
from gi.repository.Gdk import Color
|
|
|
|
from twisted.internet import gtk3reactor
|
|
gtk3reactor.install()
|
|
|
|
import txaio
|
|
txaio.use_twisted()
|
|
|
|
from twisted.internet.task import react
|
|
from twisted.internet.defer import inlineCallbacks
|
|
from twisted.internet import reactor
|
|
|
|
import web3
|
|
|
|
import numpy as np
|
|
|
|
import click
|
|
from humanize import naturaldelta, naturaltime
|
|
|
|
from autobahn.util import parse_activation_code
|
|
from autobahn.wamp.serializer import CBORSerializer
|
|
from autobahn.twisted.util import sleep
|
|
from autobahn.twisted.wamp import ApplicationRunner
|
|
from autobahn.xbr import unpack_uint256
|
|
from autobahn.xbr import account_from_seedphrase, generate_seedphrase, account_from_ethkey
|
|
from autobahn.xbr._cli import Client
|
|
from autobahn.xbr._config import UserConfig, Profile
|
|
from autobahn.xbr._util import hlval, hlid, hltype
|
|
|
|
LOGO_RESOURCE = pkg_resources.resource_filename('autobahn', 'asset/xbr_gray.svg')
|
|
print(LOGO_RESOURCE, os.path.isfile(LOGO_RESOURCE))
|
|
|
|
|
|
class ApplicationWindow(Gtk.Assistant):
|
|
"""
|
|
Main application window which provides UI for the following functions:
|
|
|
|
* N) New account
|
|
* R) Recover account:
|
|
- R1) Backup cloud device in account enabled => download encrypted account data
|
|
from cloud backup device, requires email (and 2FA) verification and password
|
|
- R2) At least one device left in account and at hand => synchronize with existing device,
|
|
direct device-to-device encrypted account data transfer
|
|
- R3) Only cold storage recovery seed phrase left => account from seed-phrase full
|
|
recovery, including new email and 2FA verification.
|
|
|
|
See also:
|
|
* https://python-gtk-3-tutorial.readthedocs.io/en/latest/
|
|
* https://twistedmatrix.com/documents/current/core/howto/choosing-reactor.html
|
|
"""
|
|
log = txaio.make_logger()
|
|
|
|
SELECTED_NONE = 0
|
|
SELECTED_NEW = 1
|
|
SELECTED_SYNCRONIZE = 2
|
|
SELECTED_RECOVER = 3
|
|
|
|
def __init__(self, reactor, session, config, config_path, profile, profile_name):
|
|
Gtk.Assistant.__init__(self)
|
|
|
|
self.reactor = reactor
|
|
self.session = session
|
|
self.config = config
|
|
self.config_path = config_path
|
|
self.profile = profile
|
|
self.profile_name = profile_name
|
|
|
|
self.input_seedphrase = None
|
|
self.input_email = None
|
|
self.input_password = None
|
|
|
|
self.output_account = None
|
|
self.output_ethadr = None
|
|
self.output_ethadr_raw = None
|
|
self.output_member_data = None
|
|
self.output_member_data_oid = uuid.UUID(bytes=b'\x00' * 16)
|
|
|
|
# configure assistant window/widget
|
|
self.set_title("XBR Network")
|
|
self.set_default_size(600, 600)
|
|
self.set_border_width(50)
|
|
self.set_resizable(False)
|
|
|
|
# setup assistant pages
|
|
self._setup_page1()
|
|
self._setup_page2()
|
|
self._setup_page3()
|
|
self._setup_page4()
|
|
self._setup_page5()
|
|
|
|
@inlineCallbacks
|
|
def start(self):
|
|
# start page depends on available user profile
|
|
if self.profile:
|
|
self.output_account = account_from_ethkey(self.profile.ethkey)
|
|
self.output_ethadr = web3.Web3.toChecksumAddress(self.output_account.address)
|
|
self.output_ethadr_raw = binascii.a2b_hex(self.output_ethadr[2:])
|
|
info = yield self.session.get_status()
|
|
if info:
|
|
now = str(np.datetime64(np.datetime64(info['status']['now'], 'ns'), 's'))
|
|
self._label5_now.set_label(now)
|
|
self._label5_chain.set_label(str(info['status']['chain']))
|
|
self._label5_status.set_label(str(info['status']['status']))
|
|
self._label5_xbrnetwork.set_label(str(info['config']['contracts']['xbrnetwork']))
|
|
self._label5_xbrtoken.set_label(str(info['config']['contracts']['xbrtoken']))
|
|
self._label5_blockhash.set_label('0x' + binascii.b2a_hex(info['status']['block']['hash']).decode())
|
|
self._label5_blocknumber.set_label(str(info['status']['block']['number']))
|
|
|
|
pprint(info)
|
|
member_data = yield self.session.get_member(self.output_ethadr_raw)
|
|
if not member_data:
|
|
self.log.info('ethadr {output_ethadr} is NOT yet a member',
|
|
output_ethadr=self.output_ethadr)
|
|
if self.profile.vaction_oid:
|
|
# switch to page "_setup_page4"
|
|
self.set_current_page(3)
|
|
else:
|
|
if self.profile.ethkey:
|
|
# switch to page "_setup_page3"
|
|
self.set_current_page(2)
|
|
else:
|
|
# switch to page "_setup_page2"
|
|
self.set_current_page(1)
|
|
else:
|
|
self.log.info('ok, ethadr {output_ethadr} already is a member: {member_data}',
|
|
output_ethadr=self.output_ethadr, member_data=member_data)
|
|
self.output_member_data = member_data
|
|
created_ago = naturaldelta((np.datetime64(time_ns(), 'ns') - self.output_member_data['created']) / 1000000000.)
|
|
created = naturaltime(np.datetime64(self.output_member_data['created'], 's'))
|
|
self._label2.set_label(str(self.output_member_data['oid']))
|
|
self._label4.set_label(str(self.output_member_data['address']))
|
|
self._label6.set_label('{} ({} ago)'.format(created, created_ago))
|
|
self._label8.set_label(str(self.output_member_data['level']))
|
|
self._label10.set_label(str(self.output_member_data['balance']['eth']))
|
|
self._label12.set_label(str(self.output_member_data['balance']['xbr']))
|
|
|
|
# switch to page "_setup_page5"
|
|
self.set_current_page(4)
|
|
else:
|
|
profile = Profile()
|
|
profile.path = self.config_path
|
|
profile.ethkey = None
|
|
profile.cskey = None
|
|
profile.username = None
|
|
profile.email = None
|
|
profile.network_url = 'ws://localhost:8090/ws'
|
|
profile.network_realm = 'xbrnetwork'
|
|
profile.member_oid = None
|
|
profile.vaction_oid = None
|
|
profile.vaction_requested = None
|
|
profile.vaction_verified = None
|
|
profile.data_url = None
|
|
profile.data_realm = None
|
|
profile.infura_url = None
|
|
profile.infura_network = None
|
|
profile.infura_key = None
|
|
profile.infura_secret = None
|
|
self.profile = profile
|
|
|
|
# switch to page "_setup_page1"
|
|
self.set_current_page(0)
|
|
|
|
def on_complete_toggled(self, checkbutton):
|
|
self.set_page_complete(self.complete, checkbutton.get_active())
|
|
|
|
# no config: select new/recovery
|
|
def _setup_page1(self):
|
|
"""
|
|
Setup page shown when no config/profile could be found. Allows to select from:
|
|
|
|
* new account
|
|
* synchronize device
|
|
* recover account
|
|
"""
|
|
grid1 = Gtk.Grid()
|
|
grid1.set_row_spacing(20)
|
|
grid1.set_column_spacing(20)
|
|
grid1.set_margin_top(20)
|
|
grid1.set_margin_bottom(20)
|
|
grid1.set_margin_start(20)
|
|
grid1.set_margin_end(20)
|
|
|
|
image1 = Gtk.Image()
|
|
|
|
image1.set_from_file(LOGO_RESOURCE)
|
|
grid1.attach(image1, 0, 0, 2, 1)
|
|
|
|
label0 = Gtk.Label(label='\n\nI am new and do not have an account yet:\n')
|
|
label0.set_alignment(0, 0.5)
|
|
grid1.attach(label0, 0, 1, 2, 1)
|
|
|
|
label1 = Gtk.Label(label='Create a new account or start from fresh. You only need an email address. [N]')
|
|
label1.set_alignment(0, 0.5)
|
|
label1.set_justify(Gtk.Justification.LEFT)
|
|
grid1.attach(label1, 1, 2, 1, 1)
|
|
|
|
button1 = Gtk.Button.new_with_label('New account')
|
|
|
|
def on_button1(res):
|
|
self.log.info('SELECTED_NEW: {res}', res=res)
|
|
self.set_current_page(1)
|
|
|
|
button1.connect('clicked', on_button1)
|
|
grid1.attach(button1, 0, 2, 1, 1)
|
|
|
|
label12 = Gtk.Label(label='\n\nI already have an existing account and want to use that:\n')
|
|
label12.set_alignment(0, 0.5)
|
|
grid1.attach(label12, 0, 3, 2, 1)
|
|
|
|
label22 = Gtk.Label(label='Restore account from cloud backup to this device. You will need access to\n'
|
|
'your account password and access to your account email address. [R1]')
|
|
label22.set_alignment(0, 0.5)
|
|
label22.set_justify(Gtk.Justification.LEFT)
|
|
label22.set_line_wrap(True)
|
|
label22.set_width_chars(12)
|
|
grid1.attach(label22, 1, 4, 1, 1)
|
|
|
|
button22 = Gtk.Button.new_with_label('Restore account')
|
|
|
|
def on_button22(res):
|
|
self.log.info('SELECTED_RESTORE: {res}', res=res)
|
|
self.set_current_page(2)
|
|
|
|
button22.connect('clicked', on_button22)
|
|
grid1.attach(button22, 0, 4, 1, 1)
|
|
|
|
label2 = Gtk.Label(label='Synchronize device with other device in account. You will need access to\n'
|
|
'another device currently connected to your account. [R2]')
|
|
label2.set_alignment(0, 0.5)
|
|
label2.set_justify(Gtk.Justification.LEFT)
|
|
label2.set_line_wrap(True)
|
|
label2.set_width_chars(12)
|
|
grid1.attach(label2, 1, 5, 1, 1)
|
|
|
|
button2 = Gtk.Button.new_with_label('Synchronize account')
|
|
|
|
def on_button2(res):
|
|
self.log.info('SELECTED_SYNCRONIZE: {res}', res=res)
|
|
self.set_current_page(2)
|
|
|
|
button2.connect('clicked', on_button2)
|
|
grid1.attach(button2, 0, 5, 1, 1)
|
|
|
|
label3 = Gtk.Label(label='Recover account from account seed phrase. You only need access to\n'
|
|
'your 12-24 word account recovery seed phrase. [R3]')
|
|
label3.set_alignment(0, 0.5)
|
|
label3.set_justify(Gtk.Justification.LEFT)
|
|
label3.set_line_wrap(True)
|
|
label3.set_width_chars(12)
|
|
grid1.attach(label3, 1, 6, 1, 1)
|
|
|
|
button3 = Gtk.Button.new_with_label('Recover account')
|
|
|
|
def on_button3(res):
|
|
self.log.info('SELECTED_RECOVER: {res}', res=res)
|
|
self.set_current_page(3)
|
|
|
|
button3.connect('clicked', on_button3)
|
|
grid1.attach(button3, 0, 6, 1, 1)
|
|
|
|
self.append_page(grid1)
|
|
|
|
# generate seed phrase
|
|
def _setup_page2(self):
|
|
"""
|
|
Setup page shown to generate a new seed phrase.
|
|
"""
|
|
box2_1 = Gtk.VBox()
|
|
|
|
box2_2 = Gtk.HBox()
|
|
image2_1 = Gtk.Image()
|
|
image2_1.set_from_file(LOGO_RESOURCE)
|
|
box2_2.add(image2_1)
|
|
box2_1.add(box2_2)
|
|
|
|
button2_1 = Gtk.Button.new_with_label('Generate seedphrase')
|
|
|
|
def on_button2_1(_):
|
|
self.input_seedphrase = generate_seedphrase(strength=256, language='english')
|
|
textbuffer2_1.set_text(self.input_seedphrase)
|
|
checkbutton2_1.set_sensitive(True)
|
|
|
|
button2_1.connect('clicked', on_button2_1)
|
|
box2_1.add(button2_1)
|
|
|
|
label2_1 = Gtk.Label(label='Backup your new seed phrase in a secure offline location (e.g. on printed paper):')
|
|
label2_1.set_alignment(0, 0.5)
|
|
label2_1.set_justify(Gtk.Justification.LEFT)
|
|
box2_1.add(label2_1)
|
|
|
|
textview2_1 = Gtk.TextView()
|
|
textbuffer2_1 = textview2_1.get_buffer()
|
|
textbuffer2_1.set_text('\n' * 5)
|
|
textview2_1.set_editable(False)
|
|
textview2_1.set_justification(Gtk.Justification.CENTER)
|
|
textview2_1.set_monospace(True)
|
|
textview2_1.set_wrap_mode(Gtk.WrapMode.WORD)
|
|
box2_1.add(textview2_1)
|
|
|
|
box2_3 = Gtk.HBox()
|
|
|
|
checkbutton2_1 = Gtk.CheckButton(label="I have backed up my seed phrase")
|
|
checkbutton2_1.set_active(False)
|
|
checkbutton2_1.set_sensitive(False)
|
|
|
|
def on_checkbutton2_1(_):
|
|
button2_2.set_sensitive(True)
|
|
|
|
checkbutton2_1.connect("toggled", on_checkbutton2_1)
|
|
box2_3.add(checkbutton2_1)
|
|
|
|
button2_2 = Gtk.Button.new_with_label('Continue')
|
|
button2_2.set_sensitive(False)
|
|
|
|
@inlineCallbacks
|
|
def on_button2_2(_):
|
|
self.output_account = account_from_seedphrase(self.input_seedphrase, index=0)
|
|
self.output_ethadr = web3.Web3.toChecksumAddress(self.output_account.address)
|
|
self.output_ethadr_raw = binascii.a2b_hex(self.output_ethadr[2:])
|
|
|
|
# https://eth-account.readthedocs.io/en/latest/eth_account.signers.html#eth_account.signers.local.LocalAccount.key
|
|
self.profile.ethkey = bytes(self.output_account.key)
|
|
self.profile.cskey = bytes(self.session._cskey_raw)
|
|
|
|
# set user eth key on client session
|
|
self.session.set_ethkey_from_profile(self.profile)
|
|
|
|
# save user config
|
|
self.config.profiles[self.profile_name] = self.profile
|
|
self.config.save(self.input_password)
|
|
|
|
self.log.info('XBR ETH key at address {ethadr} set from seed phrase (BIP39 account 0): "{seedphrase}"',
|
|
ethadr=self.output_ethadr,
|
|
seedphrase=self.input_seedphrase)
|
|
|
|
member_data = yield self.session.get_member(self.output_ethadr_raw)
|
|
pprint(member_data)
|
|
if not member_data:
|
|
self.log.info('ethadr {output_ethadr} is NOT yet a member',
|
|
output_ethadr=self.output_ethadr)
|
|
self.set_current_page(2)
|
|
else:
|
|
self.log.info('ok, ethadr {output_ethadr} already is a member: {member_data}',
|
|
output_ethadr=self.output_ethadr, member_data=member_data)
|
|
|
|
self.profile.member_oid = uuid.UUID(bytes=member_data['member_oid'])
|
|
self.profile.member_adr = self.output_ethadr
|
|
self.profile.email = member_data['email']
|
|
self.profile.username = member_data['username']
|
|
|
|
# save user config
|
|
self.config.profiles[self.profile_name] = self.profile
|
|
self.config.save(self.input_password)
|
|
|
|
self.output_member_data = member_data
|
|
self._label2.set_label(str(self._member_data['oid']))
|
|
self.set_current_page(4)
|
|
|
|
def run_on_button2_2(widget):
|
|
self.log.info('{func}({widget})', func=hltype(run_on_button2_2), widget=widget)
|
|
reactor.callLater(0, on_button2_2, widget)
|
|
|
|
button2_2.connect('clicked', run_on_button2_2)
|
|
box2_3.add(button2_2)
|
|
|
|
box2_1.add(box2_3)
|
|
|
|
self.append_page(box2_1)
|
|
|
|
# submit onboard request
|
|
def _setup_page3(self):
|
|
"""
|
|
|
|
:return:
|
|
"""
|
|
box1 = Gtk.VBox()
|
|
|
|
box2 = Gtk.HBox()
|
|
image1 = Gtk.Image()
|
|
image1.set_from_file(LOGO_RESOURCE)
|
|
box2.add(image1)
|
|
box1.add(box2)
|
|
|
|
grid1 = Gtk.Grid()
|
|
grid1.set_row_spacing(20)
|
|
grid1.set_column_spacing(20)
|
|
grid1.set_margin_top(20)
|
|
grid1.set_margin_bottom(20)
|
|
grid1.set_margin_start(20)
|
|
grid1.set_margin_end(20)
|
|
|
|
label1 = Gtk.Label(label='Your email address:')
|
|
grid1.attach(label1, 0, 0, 1, 1)
|
|
|
|
entry1 = Gtk.Entry()
|
|
entry1.set_text('')
|
|
entry1.set_max_length(255)
|
|
entry1.set_max_width_chars(40)
|
|
grid1.attach(entry1, 1, 0, 1, 1)
|
|
|
|
checks = {
|
|
'email': None,
|
|
'password': None,
|
|
'eula': None,
|
|
}
|
|
|
|
def check_all():
|
|
print('check_all')
|
|
for c in checks:
|
|
if checks[c] is None:
|
|
print('check failed', c)
|
|
button3.set_sensitive(False)
|
|
return
|
|
button3.set_sensitive(True)
|
|
|
|
def check_email(email):
|
|
if '@' in email:
|
|
return email
|
|
else:
|
|
return None
|
|
|
|
def check_password(password):
|
|
return True
|
|
|
|
def on_entry1(entry):
|
|
# joe.doe@example.com
|
|
checks['email'] = check_email(entry.get_text())
|
|
if checks['email']:
|
|
entry1.modify_fg(Gtk.StateFlags.NORMAL, None)
|
|
else:
|
|
entry1.modify_fg(Gtk.StateFlags.NORMAL, Color(50000, 0, 0))
|
|
check_all()
|
|
|
|
entry1.connect('changed', on_entry1)
|
|
|
|
label2 = Gtk.Label(label='New password:')
|
|
grid1.attach(label2, 0, 1, 1, 1)
|
|
|
|
entry2 = Gtk.Entry()
|
|
entry2.set_text('')
|
|
entry2.set_max_length(20)
|
|
entry2.set_max_width_chars(20)
|
|
entry2.set_visibility(False)
|
|
grid1.attach(entry2, 1, 1, 1, 1)
|
|
|
|
label2 = Gtk.Label(label='Repeat new password:')
|
|
grid1.attach(label2, 0, 2, 1, 1)
|
|
|
|
entry3 = Gtk.Entry()
|
|
entry3.set_text('')
|
|
entry3.set_max_length(20)
|
|
entry3.set_max_width_chars(20)
|
|
entry3.set_visibility(False)
|
|
grid1.attach(entry3, 1, 2, 1, 1)
|
|
|
|
def on_entry23(_):
|
|
pw1_ok = False
|
|
if check_password(entry2.get_text()):
|
|
pw1_ok = True
|
|
entry2.modify_fg(Gtk.StateFlags.NORMAL, None)
|
|
else:
|
|
entry2.modify_fg(Gtk.StateFlags.NORMAL, Color(50000, 0, 0))
|
|
|
|
pw2_ok = False
|
|
if check_password(entry3.get_text()):
|
|
pw2_ok = True
|
|
entry3.modify_fg(Gtk.StateFlags.NORMAL, None)
|
|
else:
|
|
entry3.modify_fg(Gtk.StateFlags.NORMAL, Color(50000, 0, 0))
|
|
|
|
if pw1_ok and pw2_ok and entry2.get_text() == entry3.get_text() and check_password(entry2.get_text()):
|
|
checks['password'] = entry2.get_text()
|
|
else:
|
|
checks['password'] = None
|
|
|
|
check_all()
|
|
|
|
entry2.connect('changed', on_entry23)
|
|
entry3.connect('changed', on_entry23)
|
|
|
|
label3 = Gtk.Label(label='EULA:')
|
|
grid1.attach(label3, 0, 3, 1, 1)
|
|
|
|
button1 = Gtk.CheckButton(label='I accept the EULA and terms of use')
|
|
button1.set_active(False)
|
|
button1.set_sensitive(True)
|
|
|
|
def on_button1(button):
|
|
if button.get_active():
|
|
checks['eula'] = True
|
|
else:
|
|
checks['eula'] = False
|
|
check_all()
|
|
|
|
button1.connect('toggled', on_button1)
|
|
grid1.attach(button1, 1, 3, 1, 1)
|
|
|
|
label3 = Gtk.Label(label='Cloud backup:')
|
|
grid1.attach(label3, 0, 4, 1, 1)
|
|
|
|
button2 = Gtk.CheckButton(label='Yes, enable encrypted cloud backup of my private keys')
|
|
button2.set_active(False)
|
|
button2.set_sensitive(True)
|
|
|
|
def on_button2(button):
|
|
check_all()
|
|
|
|
button2.connect('toggled', on_button2)
|
|
grid1.attach(button2, 1, 4, 1, 1)
|
|
|
|
button3 = Gtk.Button.new_with_label('Register account')
|
|
button3.set_sensitive(False)
|
|
|
|
@inlineCallbacks
|
|
def on_button3(_):
|
|
self.input_email = checks['email']
|
|
self.input_password = checks['password']
|
|
self.input_backup_enabled = button2.get_active()
|
|
self.input_username = 'anonymous'
|
|
self.input_username = '{}{}'.format(self.input_username, random.randint(0, 10000))
|
|
|
|
self.session.set_ethkey_from_profile(self.profile)
|
|
|
|
self.log.info('input_email: {input_email}', input_email=self.input_email)
|
|
self.log.info('input_username: {input_username}', input_username=self.input_username)
|
|
self.log.info('input_password: {input_password}', input_password=self.input_password)
|
|
result = yield self.session._do_onboard_member(self.input_username, self.input_email)
|
|
pprint(result)
|
|
|
|
self.profile.email = self.input_email
|
|
self.profile.username = self.input_username
|
|
self.profile.vaction_oid = str(uuid.UUID(bytes=result['vaction_oid']))
|
|
self.profile.vaction_requested = str(np.datetime64(result['timestamp'], 'ns'))
|
|
|
|
self.config.profiles[self.profile_name] = self.profile
|
|
self.config.save(self.input_password)
|
|
|
|
self.set_current_page(3)
|
|
|
|
def run_on_button3(widget):
|
|
self.log.info('{func}({widget})', func=hltype(run_on_button3), widget=widget)
|
|
reactor.callLater(0, on_button3, widget)
|
|
|
|
button3.connect('clicked', run_on_button3)
|
|
grid1.attach(button3, 2, 4, 1, 1)
|
|
|
|
box1.add(grid1)
|
|
|
|
self.append_page(box1)
|
|
|
|
# submit verification code
|
|
def _setup_page4(self):
|
|
"""
|
|
Page shown when member registration request was submitted, a verification email
|
|
sent, and the verification request ID returned.
|
|
The user now should check the email inbox for the received verification code,
|
|
and continue verifying the code.
|
|
|
|
:return:
|
|
"""
|
|
box1 = Gtk.VBox()
|
|
|
|
box2 = Gtk.HBox()
|
|
image1 = Gtk.Image()
|
|
image1.set_from_file(LOGO_RESOURCE)
|
|
box2.add(image1)
|
|
box1.add(box2)
|
|
|
|
box3 = Gtk.HBox()
|
|
label1 = Gtk.Label(label='Member registration submitted, verification request:')
|
|
label2 = Gtk.Label(label='8d5d7ffd-23d9-45a0-a686-00a49f29d3cd')
|
|
box3.add(label1)
|
|
box3.add(label2)
|
|
box1.add(box3)
|
|
|
|
label3 = Gtk.Label(label='Please check your email inbox, and enter the verification code received here:')
|
|
box1.add(label3)
|
|
|
|
entry1 = Gtk.Entry()
|
|
entry1.set_text('')
|
|
entry1.set_max_length(255)
|
|
entry1.set_max_width_chars(40)
|
|
box1.add(entry1)
|
|
|
|
def on_entry1(entry):
|
|
# "RWCN-94NV-CEHR" -> ("RWCN", "94NV", "CEHR") | None
|
|
vaction_code = parse_activation_code(entry.get_text())
|
|
if vaction_code:
|
|
entry1.modify_fg(Gtk.StateFlags.NORMAL, None)
|
|
button1.set_sensitive(True)
|
|
else:
|
|
entry1.modify_fg(Gtk.StateFlags.NORMAL, Color(50000, 0, 0))
|
|
button1.set_sensitive(False)
|
|
|
|
entry1.connect('changed', on_entry1)
|
|
|
|
button1 = Gtk.Button.new_with_label('Verify')
|
|
button1.set_sensitive(False)
|
|
|
|
@inlineCallbacks
|
|
def on_button1(_):
|
|
vaction_code = parse_activation_code(entry1.get_text())
|
|
if vaction_code:
|
|
vaction_code = '-'.join(vaction_code.groups())
|
|
if type(self.profile.vaction_oid) == str:
|
|
vaction_oid = uuid.UUID(self.profile.vaction_oid)
|
|
else:
|
|
vaction_oid = self.profile.vaction_oid
|
|
result = yield self.session._do_onboard_member_verify(vaction_oid, vaction_code)
|
|
pprint(result)
|
|
|
|
self.profile.vaction_verified = str(np.datetime64(result['created'], 'ns'))
|
|
self.profile.vaction_transaction = '0x' + str(binascii.b2a_hex(result['transaction']).decode())
|
|
self.profile.member_oid = str(uuid.UUID(bytes=result['member_oid']))
|
|
self.config.profiles[self.profile_name] = self.profile
|
|
self.config.save(self.input_password)
|
|
|
|
def run_on_button1(widget):
|
|
self.log.info('{func}({widget})', func=hltype(run_on_button1), widget=widget)
|
|
reactor.callLater(0, on_button1, widget)
|
|
|
|
button1.connect('clicked', run_on_button1)
|
|
box1.add(button1)
|
|
|
|
self.append_page(box1)
|
|
|
|
# show member data
|
|
def _setup_page5(self):
|
|
"""
|
|
Page shown for a user (private eth key) that already is member.
|
|
|
|
:return:
|
|
"""
|
|
box1 = Gtk.VBox()
|
|
|
|
box2 = Gtk.HBox()
|
|
image1 = Gtk.Image()
|
|
image1.set_from_file(LOGO_RESOURCE)
|
|
box2.add(image1)
|
|
box1.add(box2)
|
|
|
|
grid2 = Gtk.Grid()
|
|
grid2.set_row_spacing(20)
|
|
grid2.set_column_spacing(20)
|
|
grid2.set_margin_top(20)
|
|
grid2.set_margin_bottom(20)
|
|
grid2.set_margin_start(20)
|
|
grid2.set_margin_end(20)
|
|
|
|
grid2_y = 0
|
|
|
|
# Current server time
|
|
#
|
|
label5_now_title = Gtk.Label(label='Current server time:')
|
|
label5_now_title.set_alignment(1, 0.5)
|
|
grid2.attach(label5_now_title, 0, grid2_y, 1, 1)
|
|
self._label5_now = Gtk.Label()
|
|
self._label5_now.set_alignment(0, 0.5)
|
|
self._label5_now.set_selectable(False)
|
|
grid2.attach(self._label5_now, 1, grid2_y, 1, 1)
|
|
grid2_y += 1
|
|
|
|
# Blockchain ID (e.g. 1, 3 or 5777)
|
|
#
|
|
label5_chain_title = Gtk.Label(label='Blockchain ID:')
|
|
label5_chain_title.set_alignment(1, 0.5)
|
|
grid2.attach(label5_chain_title, 0, grid2_y, 1, 1)
|
|
self._label5_chain = Gtk.Label()
|
|
self._label5_chain.set_alignment(0, 0.5)
|
|
self._label5_chain.set_selectable(True)
|
|
grid2.attach(self._label5_chain, 1, grid2_y, 1, 1)
|
|
grid2_y += 1
|
|
|
|
# Current server time
|
|
#
|
|
label5_status_title = Gtk.Label(label='Service status:')
|
|
label5_status_title.set_alignment(1, 0.5)
|
|
grid2.attach(label5_status_title, 0, grid2_y, 1, 1)
|
|
self._label5_status = Gtk.Label()
|
|
self._label5_status.set_alignment(0, 0.5)
|
|
self._label5_status.set_selectable(False)
|
|
grid2.attach(self._label5_status, 1, grid2_y, 1, 1)
|
|
grid2_y += 1
|
|
|
|
# xbrnetwork address
|
|
#
|
|
label5_xbrnetwork_title = Gtk.Label(label='XBRNetwork contract:')
|
|
label5_xbrnetwork_title.set_alignment(1, 0.5)
|
|
grid2.attach(label5_xbrnetwork_title, 0, grid2_y, 1, 1)
|
|
self._label5_xbrnetwork = Gtk.Label()
|
|
self._label5_xbrnetwork.set_alignment(0, 0.5)
|
|
self._label5_xbrnetwork.set_selectable(True)
|
|
grid2.attach(self._label5_xbrnetwork, 1, grid2_y, 1, 1)
|
|
grid2_y += 1
|
|
|
|
# xbrtoken address
|
|
#
|
|
label5_xbrtoken_title = Gtk.Label(label='XBRToken contract:')
|
|
label5_xbrtoken_title.set_alignment(1, 0.5)
|
|
grid2.attach(label5_xbrtoken_title, 0, grid2_y, 1, 1)
|
|
self._label5_xbrtoken = Gtk.Label()
|
|
self._label5_xbrtoken.set_alignment(0, 0.5)
|
|
self._label5_xbrtoken.set_selectable(True)
|
|
grid2.attach(self._label5_xbrtoken, 1, grid2_y, 1, 1)
|
|
grid2_y += 1
|
|
|
|
# Current block hash
|
|
#
|
|
label5_blockhash_title = Gtk.Label(label='Current block hash:')
|
|
label5_blockhash_title.set_alignment(1, 0.5)
|
|
grid2.attach(label5_blockhash_title, 0, grid2_y, 1, 1)
|
|
self._label5_blockhash = Gtk.Label()
|
|
self._label5_blockhash.set_alignment(0, 0.5)
|
|
self._label5_blockhash.set_selectable(True)
|
|
grid2.attach(self._label5_blockhash, 1, grid2_y, 1, 1)
|
|
grid2_y += 1
|
|
|
|
# Current block number
|
|
#
|
|
label5_blocknumber_title = Gtk.Label(label='Current block number:')
|
|
label5_blocknumber_title.set_alignment(1, 0.5)
|
|
grid2.attach(label5_blocknumber_title, 0, grid2_y, 1, 1)
|
|
self._label5_blocknumber = Gtk.Label()
|
|
self._label5_blocknumber.set_alignment(0, 0.5)
|
|
self._label5_blocknumber.set_selectable(True)
|
|
grid2.attach(self._label5_blocknumber, 1, grid2_y, 1, 1)
|
|
grid2_y += 1
|
|
|
|
box1.add(grid2)
|
|
|
|
grid1 = Gtk.Grid()
|
|
grid1.set_row_spacing(20)
|
|
grid1.set_column_spacing(20)
|
|
grid1.set_margin_top(20)
|
|
grid1.set_margin_bottom(20)
|
|
grid1.set_margin_start(20)
|
|
grid1.set_margin_end(20)
|
|
|
|
label1 = Gtk.Label(label='User ID:')
|
|
label1.set_alignment(1, 0.5)
|
|
grid1.attach(label1, 0, 0, 1, 1)
|
|
|
|
self._label2 = Gtk.Label()
|
|
self._label2.set_alignment(0, 0.5)
|
|
self._label2.set_selectable(True)
|
|
grid1.attach(self._label2, 1, 0, 1, 1)
|
|
|
|
label3 = Gtk.Label(label='Eth Address:')
|
|
label3.set_alignment(1, 0.5)
|
|
grid1.attach(label3, 0, 1, 1, 1)
|
|
|
|
self._label4 = Gtk.Label()
|
|
self._label4.set_alignment(0, 0.5)
|
|
self._label4.set_selectable(True)
|
|
grid1.attach(self._label4, 1, 1, 1, 1)
|
|
|
|
label5 = Gtk.Label(label='Account Created:')
|
|
label5.set_alignment(1, 0.5)
|
|
grid1.attach(label5, 0, 2, 1, 1)
|
|
|
|
self._label6 = Gtk.Label()
|
|
self._label6.set_alignment(0, 0.5)
|
|
grid1.attach(self._label6, 1, 2, 1, 1)
|
|
|
|
label7 = Gtk.Label(label='Membership:')
|
|
label7.set_alignment(1, 0.5)
|
|
grid1.attach(label7, 0, 3, 1, 1)
|
|
|
|
self._label8 = Gtk.Label()
|
|
self._label8.set_alignment(0, 0.5)
|
|
grid1.attach(self._label8, 1, 3, 1, 1)
|
|
|
|
label9 = Gtk.Label(label='ETH Balance:')
|
|
label9.set_alignment(1, 0.5)
|
|
grid1.attach(label9, 0, 4, 1, 1)
|
|
|
|
self._label10 = Gtk.Label()
|
|
self._label10.set_alignment(0, 0.5)
|
|
grid1.attach(self._label10, 1, 4, 1, 1)
|
|
|
|
label11 = Gtk.Label(label='XBR Balance:')
|
|
label11.set_alignment(1, 0.5)
|
|
grid1.attach(label11, 0, 5, 1, 1)
|
|
|
|
self._label12 = Gtk.Label()
|
|
self._label12.set_alignment(0, 0.5)
|
|
grid1.attach(self._label12, 1, 5, 1, 1)
|
|
|
|
box1.add(grid1)
|
|
|
|
self.append_page(box1)
|
|
|
|
|
|
class ApplicationClient(Client):
|
|
async def onJoin(self, details):
|
|
self.log.info('Ok, client joined on realm "{realm}" [session={session}, authid="{authid}", authrole="{authrole}"]',
|
|
realm=hlid(details.realm),
|
|
session=hlid(details.session),
|
|
authid=hlid(details.authid),
|
|
authrole=hlid(details.authrole),
|
|
details=details)
|
|
if 'ready' in self.config.extra:
|
|
txaio.resolve(self.config.extra['ready'], (self, details))
|
|
|
|
@inlineCallbacks
|
|
def get_status(self):
|
|
if self.is_attached():
|
|
config = yield self.call('xbr.network.get_config')
|
|
status = yield self.call('xbr.network.get_status')
|
|
return {'config': config, 'status': status}
|
|
else:
|
|
self.log.warn('not connected: could not retrieve status')
|
|
|
|
@inlineCallbacks
|
|
def get_member(self, ethadr_raw):
|
|
if self.is_attached():
|
|
is_member = yield self.call('xbr.network.is_member', ethadr_raw)
|
|
if is_member:
|
|
member_data = yield self.call('xbr.network.get_member_by_wallet', ethadr_raw)
|
|
|
|
member_data['address'] = web3.Web3.toChecksumAddress(member_data['address'])
|
|
member_data['oid'] = uuid.UUID(bytes=member_data['oid'])
|
|
member_data['balance']['eth'] = web3.Web3.fromWei(unpack_uint256(member_data['balance']['eth']),
|
|
'ether')
|
|
member_data['balance']['xbr'] = web3.Web3.fromWei(unpack_uint256(member_data['balance']['xbr']),
|
|
'ether')
|
|
member_data['created'] = np.datetime64(member_data['created'], 'ns')
|
|
|
|
member_level = member_data['level']
|
|
member_data['level'] = {
|
|
# Member is active.
|
|
1: 'ACTIVE',
|
|
# Member is active and verified.
|
|
2: 'VERIFIED',
|
|
# Member is retired.
|
|
3: 'RETIRED',
|
|
# Member is subject to a temporary penalty.
|
|
4: 'PENALTY',
|
|
# Member is currently blocked and cannot current actively participate in the market.
|
|
5: 'BLOCKED',
|
|
}.get(member_level, None)
|
|
|
|
self.log.info(
|
|
'Member {member_oid} found for address 0x{member_adr} - current member level {member_level}',
|
|
member_level=hlval(member_data['level']),
|
|
member_oid=hlid(member_data['oid']),
|
|
member_adr=hlval(member_data['address']))
|
|
|
|
return member_data
|
|
else:
|
|
self.log.warn('Address {output_ethadr} is not a member in the XBR network',
|
|
output_ethadr=ethadr_raw)
|
|
else:
|
|
self.log.warn('not connected: could not retrieve member data for address {output_ethadr}',
|
|
output_ethadr=ethadr_raw)
|
|
|
|
|
|
class Application(object):
|
|
"""
|
|
Main XBR member application.
|
|
"""
|
|
log = txaio.make_logger()
|
|
|
|
DOTDIR = os.path.abspath(os.path.expanduser('~/.xbrnetwork'))
|
|
DOTFILE = 'config.ini'
|
|
|
|
async def start(self, reactor, url=None, realm=None, profile=None):
|
|
"""
|
|
Start main application. This will read the user configuration, potentially asking
|
|
for a user password.
|
|
|
|
:param reactor: Twisted reactor to use.
|
|
:param url: Optionally override network URL as defined in profile.
|
|
:param realm: Optionally override network URL as defined in profile.
|
|
:param profile: User profile name to load.
|
|
:return:
|
|
"""
|
|
txaio.start_logging(level='info')
|
|
|
|
self.log.info('ok, application starting for user profile "{profile}"', profile=profile)
|
|
|
|
if not os.path.isdir(self.DOTDIR):
|
|
os.mkdir(self.DOTDIR)
|
|
self.log.info('dotdir created: "{dotdir}"', dotdir=self.DOTDIR)
|
|
|
|
self._config_path = config_path = os.path.join(self.DOTDIR, self.DOTFILE)
|
|
self._profile_name = profile or 'default'
|
|
if not os.path.isfile(self._config_path):
|
|
self.log.info('no config exist under "{config_path}"', config_path=self._config_path)
|
|
self._config = UserConfig(self._config_path)
|
|
self._profile = None
|
|
else:
|
|
self._config = UserConfig(self._config_path)
|
|
# FIXME: start modal dialog to get password from user
|
|
|
|
def getpw():
|
|
return '123secret'
|
|
|
|
self._config.load(cb_get_password=getpw)
|
|
if self._profile_name not in self._config.profiles:
|
|
raise click.ClickException('no such profile "{}" in config "{}" with {} profiles'.format(self._profile_name, config_path, len(self._config.profiles)))
|
|
else:
|
|
self._profile = self._config.profiles[self._profile_name]
|
|
self.log.info('user profile "{profile_name}" loaded from "{config_path}":\n\n',
|
|
config_path=self._config_path, profile_name=self._profile_name)
|
|
pprint(self._profile.marshal())
|
|
print('\n\n')
|
|
|
|
extra = {
|
|
'ready': txaio.create_future(),
|
|
'done': txaio.create_future(),
|
|
'running': True,
|
|
'config': self._config,
|
|
'config_path': self._config_path,
|
|
'profile': self._profile,
|
|
'profile_name': self._profile_name,
|
|
}
|
|
# XBR network node used as a directory server and gateway to XBR smart contracts
|
|
network_url = url or (self._profile.network_url if self._profile and self._profile.network_url else 'ws://localhost:8090/ws')
|
|
|
|
# WAMP realm on network node, usually "xbrnetwork"
|
|
network_realm = realm or (self._profile.network_realm if self._profile and self._profile.network_realm else 'xbrnetwork')
|
|
|
|
runner = ApplicationRunner(url=network_url,
|
|
realm=network_realm,
|
|
extra=extra,
|
|
serializers=[CBORSerializer()])
|
|
|
|
self.log.info('ok, now connecting to "{network_url}", joining realm "{network_realm}" ..',
|
|
network_url=network_url,
|
|
network_realm=network_realm)
|
|
await runner.run(ApplicationClient,
|
|
reactor=reactor,
|
|
auto_reconnect=True,
|
|
start_reactor=False)
|
|
self.log.info('ok, application client connected!')
|
|
|
|
session, details = await extra['ready']
|
|
self.log.info('ok, application session joined: {details}', details=details)
|
|
|
|
def on_exit(_):
|
|
self.log.info('exiting application ..')
|
|
extra['running'] = False
|
|
txaio.resolve(extra['done'], None)
|
|
|
|
win = ApplicationWindow(reactor, session, self._config, self._config_path, self._profile, self._profile_name)
|
|
win.connect("cancel", on_exit)
|
|
win.connect("destroy", on_exit)
|
|
win.show_all()
|
|
|
|
await win.start()
|
|
|
|
ticks = 0
|
|
while extra['running']:
|
|
ticks += 1
|
|
self.log.info('ok, application main task still running at tick {ticks}', ticks=ticks)
|
|
await sleep(5)
|
|
|
|
self.log.info('ok, application main task ended!')
|
|
|
|
|
|
async def main(reactor, url, realm, profile):
|
|
"""
|
|
Load the named user profile (or create a new one), overriding URL/realm,
|
|
connect to a network node, and start the network member on-boarding.
|
|
|
|
If the user credentials are already for a member, fetch member information
|
|
and display member page.
|
|
|
|
:param reactor: Twisted reactor to use.
|
|
:param url: Override network URL from user profile with this value.
|
|
:param realm: Override network realm from user profile with this value.
|
|
:param profile: Name of user profile within user
|
|
configuration to load (eg from ``$HOME/.xbrnetwork/config.ini``)
|
|
"""
|
|
app = Application()
|
|
await app.start(reactor, url=url, realm=realm, profile=profile)
|
|
|
|
|
|
def _main():
|
|
"""
|
|
GUI entry point, parsing command line arguments and then starting the
|
|
actual main GUI program with parsed parameters.
|
|
|
|
To use, run:
|
|
|
|
.. code:: console
|
|
|
|
xbrnetwork-ui --profile default --url ws://localhost:8090/ws --realm xbrnetwork
|
|
|
|
This will load the user profile ``"default"`` from the user configuration, but
|
|
overriding any network URL and realm found therin.
|
|
"""
|
|
parser = argparse.ArgumentParser()
|
|
|
|
parser.add_argument('--url',
|
|
dest='url',
|
|
type=str,
|
|
default=None,
|
|
help='The router URL to connect to, e.g. "ws://localhost:8090/ws"')
|
|
|
|
parser.add_argument('--realm',
|
|
dest='realm',
|
|
type=str,
|
|
default=None,
|
|
help='The realm to join, e.g. "xbrnetwork"')
|
|
|
|
parser.add_argument('--profile',
|
|
dest='profile',
|
|
type=str,
|
|
default='default',
|
|
help='The user profile to use, e.g. "default"')
|
|
|
|
args = parser.parse_args()
|
|
|
|
react(main, (args.url, args.realm, args.profile,))
|
|
|
|
|
|
if __name__ == '__main__':
|
|
_main()
|