async def do_get(self, url="/labels"):
url = 'https://' + self.target_host + url
network = Network.get_instance()
proxy = network.proxy if network else None
async with make_aiohttp_session(proxy) as session:
async with session.get(url) as result:
return await result.json()
def __init__(self, config: 'SimpleConfig', exctype, value, tb):
BaseCrashReporter.__init__(self, exctype, value, tb)
self.network = Network.get_instance()
self.config = config
QWidget.__init__(self)
self.setWindowTitle('Firo Electrum - ' + _('An Error Occurred'))
self.setMinimumSize(600, 300)
Logger.__init__(self)
main_box = QVBoxLayout()
heading = QLabel('<h2>' + BaseCrashReporter.CRASH_TITLE + '</h2>')
main_box.addWidget(heading)
main_box.addWidget(QLabel(BaseCrashReporter.CRASH_MESSAGE))
main_box.addWidget(QLabel(BaseCrashReporter.REQUEST_HELP_MESSAGE))
collapse_info = QPushButton(_("Show report contents"))
collapse_info.clicked.connect(
lambda: self.msg_box(QMessageBox.NoIcon,
self,
_("Report contents"),
self.get_report_string(),
rich_text=True))
main_box.addWidget(collapse_info)
main_box.addWidget(QLabel(BaseCrashReporter.DESCRIBE_ERROR_MESSAGE))
self.description_textfield = QTextEdit()
self.description_textfield.setFixedHeight(50)
self.description_textfield.setPlaceholderText(
_("Do not enter sensitive/private information here. "
"The report will be visible on the public issue tracker."))
main_box.addWidget(self.description_textfield)
main_box.addWidget(QLabel(BaseCrashReporter.ASK_CONFIRM_SEND))
buttons = QHBoxLayout()
report_button = QPushButton(_('Send Bug Report'))
report_button.clicked.connect(self.send_report)
report_button.setIcon(read_QIcon("tab_send.png"))
buttons.addWidget(report_button)
never_button = QPushButton(_('Never'))
never_button.clicked.connect(self.show_never)
buttons.addWidget(never_button)
close_button = QPushButton(_('Not Now'))
close_button.clicked.connect(self.close)
buttons.addWidget(close_button)
main_box.addLayout(buttons)
self.setLayout(main_box)
self.show()
async def do_scan(self, wallet, cnt):
w = wallet
try:
async with self.wallet_scans_lock:
ws = self.wallet_scans.get(w)
if not ws or ws.running:
return
ws.running = True
scans = list(ws.scans.values())
n = Network.get_instance()
loop = n.asyncio_loop
done_cnt = 0
to_scan_cnt = 0
for s in scans:
if not s.active:
continue
to_scan_cnt += len(s.uncompleted)
if to_scan_cnt:
self.logger.info(f'total count to rescan: {to_scan_cnt}')
else:
for s in scans:
if not s.active:
continue
async with self.wallet_scans_lock:
await loop.run_in_executor(None, s.derive_addrs, cnt)
to_scan_cnt += cnt
self.logger.info(f'total count to scan: {to_scan_cnt}')
if not to_scan_cnt:
return
async with TaskGroup() as group:
for s in scans:
for i, addr in s.addrs.items():
if i in s.balances:
continue
script = bitcoin.address_to_script(addr)
scripthash = bitcoin.script_to_scripthash(script)
coro = n.get_balance_for_scripthash(scripthash)
s.tasks[i] = await group.spawn(coro)
while True:
task = await group.next_done()
if task is None:
break
done_cnt += 1
await self.on_progress(w, 100 * done_cnt / to_scan_cnt)
for s in scans:
for i, task in s.tasks.items():
try:
balance = task.result()
s.balances[i] = balance_total(**balance)
if i in s.errors:
s.errors.pop(i)
except BaseException as e:
self.logger.info(f'Exception on get_balance {repr(e)}')
s.errors[i] = e
s.tasks.clear()
await self.on_completed(w)
except Exception as e:
self.logger.info(f'Exception during wallet_scan: {repr(e)}')
await self.on_error(w, e)
async def do_post(self, url="/labels", data=None):
url = 'https://' + self.target_host + url
network = Network.get_instance()
proxy = network.proxy if network else None
async with make_aiohttp_session(proxy) as session:
async with session.post(url, json=data) as result:
try:
return await result.json()
except Exception as e:
raise Exception('Could not decode: ' +
await result.text()) from e
async def add_found(self, wallet):
w = wallet
try:
n = Network.get_instance()
loop = n.asyncio_loop
async with self.wallet_scans_lock:
ws = self.wallet_scans.get(w)
if not ws or ws.running:
return
ws.running = True
scans = list(ws.scans.values())
for s in scans:
await loop.run_in_executor(None, s.create_new_addrs, w)
await self.on_completed(w)
except Exception as e:
self.logger.info(f'Exception during add_found: {repr(e)}')
await self.on_error(w, e)
def comserver_post_notification(self, payload):
assert self.is_mobile_paired(), "unexpected mobile pairing error"
url = 'https://digitalbitbox.com/smartverification/index.php'
key_s = base64.b64decode(
self.digitalbitbox_config[ENCRYPTION_PRIVKEY_KEY])
args = 'c=data&s=0&dt=0&uuid=%s&pl=%s' % (
self.digitalbitbox_config[CHANNEL_ID_KEY],
EncodeAES_base64(
key_s,
json.dumps(payload).encode('ascii')).decode('ascii'),
)
try:
text = Network.send_http_on_proxy(
'post',
url,
body=args.encode('ascii'),
headers={'content-type': 'application/x-www-form-urlencoded'})
_logger.info(f'digitalbitbox reply from server {text}')
except Exception as e:
self.handler.show_error(
repr(e)) # repr because str(Exception()) == ''
def __init__(self, app, plugin):
super(ScanOverGapPopup, self).__init__()
self.app = app
self.wallet = w = app.wallet
self.plugin = p = plugin
self.title = plugin.MSG_TITLE
self.network = Network.get_instance()
coro = plugin.init_scans(w)
fut = asyncio.run_coroutine_threadsafe(coro, self.network.asyncio_loop)
fut.result()
box = self.box
box.add_widget(Factory.WWLabel(text=p.MSG_SCAN_TITLE),
len(box.children))
self.scan_list = ScanList(self)
self.scan_list.update()
box.add_widget(self.scan_list, len(box.children) - 1)
self.set_do_scan_btn_txt(p.DEF_SCAN_CNT)
self.reset_scans_btn.text = p.MSG_RESET
self.add_found_btn.text = p.MSG_ADD_FOUND
self.scan_count_msg = p.MSG_SCAN_COUNT
self.scan_cnt_sb.min = p.MIN_SCAN_CNT
self.scan_cnt_sb.max = p.MAX_SCAN_CNT
self.scan_cnt_sb.step = p.DEF_SCAN_CNT
self.scan_cnt_sb.val = p.DEF_SCAN_CNT
self.scan_progress_msg = p.MSG_PROGRESS
ws = self.plugin.wallet_scans.get(w)
self.scan_progress_pb.value = ws.progress
if ws.running:
self.scan_cnt_sb.disabled = True
self.do_scan_btn.disabled = True
self.reset_scans_btn.disabled = True
self.set_add_found_bnt_state()
ScanOverGapEvents.bind(on_completed=self.on_completed_kivy)
ScanOverGapEvents.bind(on_progress=self.on_progress_kivy)
ScanOverGapEvents.bind(on_error=self.on_error_kivy)
#!/usr/bin/env python3
import json
import asyncio
from electrum_firo.simple_config import SimpleConfig
from electrum_firo.network import filter_version, Network
from electrum_firo.util import create_and_start_event_loop, log_exceptions
from electrum_firo import constants
# testnet?
#constants.set_testnet()
config = SimpleConfig({'testnet': False})
loop, stopping_fut, loop_thread = create_and_start_event_loop()
network = Network(config)
network.start()
@log_exceptions
async def f():
try:
peers = await network.get_peers()
peers = filter_version(peers)
print(json.dumps(peers, sort_keys=True, indent=4))
finally:
stopping_fut.set_result(1)
asyncio.run_coroutine_threadsafe(f(), loop)
def is_available(self):
if Network.get_instance():
return True
self.logger.warning(f'Plugin {self.name} unavailable in offline mode')
return False
#!/usr/bin/env python3
# A simple script that connects to a server and displays block headers
import time
import asyncio
from electrum_firo.network import Network
from electrum_firo.util import print_msg, json_encode, create_and_start_event_loop, log_exceptions
from electrum_firo.simple_config import SimpleConfig
config = SimpleConfig()
# start network
loop, stopping_fut, loop_thread = create_and_start_event_loop()
network = Network(config)
network.start()
# wait until connected
while not network.is_connected():
time.sleep(1)
print_msg("waiting for network to get connected...")
header_queue = asyncio.Queue()
@log_exceptions
async def f():
try:
await network.interface.session.subscribe(
'blockchain.headers.subscribe', [], header_queue)
def __init__(self):
QThread.__init__(self)
Logger.__init__(self)
self.network = Network.get_instance()
def recovery(self):
network = Network.get_instance()
coroutine = account_discovery(network, self.get_account_xpub)
return network.run_from_another_thread(coroutine)
def update(self, *, network: Network, servers: dict, use_tor: bool):
self.clear()
# connected servers
connected_servers_item = QTreeWidgetItem([_("Connected nodes"), ''])
connected_servers_item.setData(0, self.ITEMTYPE_ROLE,
self.ItemType.TOPLEVEL)
chains = network.get_blockchains()
n_chains = len(chains)
for chain_id, interfaces in chains.items():
b = blockchain.blockchains.get(chain_id)
if b is None: continue
name = b.get_name()
if n_chains > 1:
x = QTreeWidgetItem(
[name + '@%d' % b.get_max_forkpoint(),
'%d' % b.height()])
x.setData(0, self.ITEMTYPE_ROLE, self.ItemType.CHAIN)
x.setData(0, self.CHAIN_ID_ROLE, b.get_id())
else:
x = connected_servers_item
for i in interfaces:
star = ' *' if i == network.interface else ''
item = QTreeWidgetItem(
[f"{i.server.net_addr_str()}" + star,
'%d' % i.tip])
item.setData(0, self.ITEMTYPE_ROLE,
self.ItemType.CONNECTED_SERVER)
item.setData(0, self.SERVER_ADDR_ROLE, i.server)
item.setToolTip(0, str(i.server))
x.addChild(item)
if n_chains > 1:
connected_servers_item.addChild(x)
# disconnected servers
disconnected_servers_item = QTreeWidgetItem(
[_("Other known servers"), ""])
disconnected_servers_item.setData(0, self.ITEMTYPE_ROLE,
self.ItemType.TOPLEVEL)
connected_hosts = set(
[iface.host for ifaces in chains.values() for iface in ifaces])
protocol = PREFERRED_NETWORK_PROTOCOL
for _host, d in sorted(servers.items()):
if _host in connected_hosts:
continue
if _host.endswith('.onion') and not use_tor:
continue
port = d.get(protocol)
if port:
server = ServerAddr(_host, port, protocol=protocol)
item = QTreeWidgetItem([server.net_addr_str(), ""])
item.setData(0, self.ITEMTYPE_ROLE,
self.ItemType.DISCONNECTED_SERVER)
item.setData(0, self.SERVER_ADDR_ROLE, server)
disconnected_servers_item.addChild(item)
self.addTopLevelItem(connected_servers_item)
self.addTopLevelItem(disconnected_servers_item)
connected_servers_item.setExpanded(True)
for i in range(connected_servers_item.childCount()):
connected_servers_item.child(i).setExpanded(True)
disconnected_servers_item.setExpanded(True)
# headers
h = self.header()
h.setStretchLastSection(False)
h.setSectionResizeMode(0, QHeaderView.Stretch)
h.setSectionResizeMode(1, QHeaderView.ResizeToContents)
super().update()
def __init__(self, window, plugin):
WindowModalDialog.__init__(self, window, plugin.MSG_TITLE)
self.setMinimumSize(800, 400)
self.wallet = w = window.parent().wallet
self.plugin = plugin
self.config = plugin.config
self.network = Network.get_instance()
coro = plugin.init_scans(w)
fut = asyncio.run_coroutine_threadsafe(coro, self.network.asyncio_loop)
fut.result()
g = QGridLayout(self)
g.addWidget(WWLabel(plugin.MSG_SCAN_TITLE), 0, 0, 1, -1)
self.scan_list = ScanListWidget(self)
self.scan_list.update()
self.scan_list.itemChanged.connect(self.scan_list_item_changed)
g.addWidget(self.scan_list, 1, 0, 1, -1)
g.addWidget(QLabel(plugin.MSG_SCAN_COUNT), 2, 0)
self.scan_cnt_sb = QSpinBox()
self.scan_cnt_sb.setRange(plugin.MIN_SCAN_CNT, plugin.MAX_SCAN_CNT)
self.scan_cnt_sb.setValue(plugin.DEF_SCAN_CNT)
self.scan_cnt_sb.setSingleStep(plugin.DEF_SCAN_CNT)
self.scan_cnt_sb.valueChanged.connect(self.on_scan_cnt_value_changed)
g.addWidget(self.scan_cnt_sb, 2, 1)
self.do_scan_btn = QPushButton()
self.set_do_scan_btn_txt(plugin.DEF_SCAN_CNT)
self.do_scan_btn.clicked.connect(partial(self.do_scan, w))
g.addWidget(self.do_scan_btn, 2, 3)
g.addWidget(QLabel(plugin.MSG_PROGRESS), 2, 4)
self.scan_progress_pb = QProgressBar()
self.scan_progress_pb.setValue(0)
g.addWidget(self.scan_progress_pb , 2, 5)
g.setRowStretch(10, 1)
hbox = QHBoxLayout()
self.reset_scans_btn = QPushButton(plugin.MSG_RESET)
self.reset_scans_btn.clicked.connect(partial(self.reset_scans, w))
hbox.addWidget(self.reset_scans_btn)
hbox.addStretch(1)
self.add_found_btn = QPushButton(plugin.MSG_ADD_FOUND)
self.add_found_btn.clicked.connect(partial(self.add_found_coins, w))
hbox.addWidget(self.add_found_btn)
hbox.addWidget(CloseButton(self))
g.addLayout(hbox, 11, 0, 1, -1)
self.plugin.progress_sig.s.connect(self.on_progress_qt)
self.plugin.completed_sig.s.connect(self.on_completed_qt)
self.plugin.error_sig.s.connect(self.on_error_qt)
self.cleaned_up = False
ws = self.plugin.wallet_scans.get(w)
self.scan_progress_pb.setValue(ws.progress)
if ws.running:
self.scan_cnt_sb.setEnabled(False)
self.do_scan_btn.setEnabled(False)
self.reset_scans_btn.setEnabled(False)
self.set_add_found_bnt_state()
