def _send(self, parent, blob):
def sender_thread():
with self._audio_interface() as interface:
src = BytesIO(blob)
dst = interface.player()
amodem.main.send(config=self.modem_config, src=src, dst=dst)
print_msg('Sending:', repr(blob))
blob = zlib.compress(blob.encode('ascii'))
kbps = self.modem_config.modem_bps / 1e3
msg = 'Sending to Audio MODEM ({0:.1f} kbps)...'.format(kbps)
WaitingDialog(parent, msg, sender_thread)
def do_send(self, tx, d):
def on_success(result):
[server.put(t[1] + '_signed', 'True') for t in self.keys]
release_locks()
self.window.show_message(
_("Your transaction was sent to the cosigning pool.") + '\n' +
_("Open your cosigner wallet to retrieve it."))
time.sleep(1)
d.close()
def on_failure(exc_info):
e = exc_info[1]
try:
self.logger.error("on_failure", exc_info=exc_info)
except OSError:
pass
self.window.show_error(
_("Failed to send transaction to cosigning pool. Please resend"
) + ':\n' + str(e))
def release_locks():
wallet = self.window.wallet
if type(wallet) == Multisig_Wallet:
for key, _hash, window in self.keys:
# delete lock blocking other wallets from opening TX dialog
server.delete(_hash + '_lock')
# set pick flag to true
server.put(_hash + '_pick', 'True')
# set graceful shutdown flag to down to signify a graceful shutdown
server.put(_hash + '_shutdown', 'down')
def send_to_cosigner():
for window, xpub, K, _hash in self.cosigner_list:
if not self.cosigner_can_sign(tx, xpub):
continue
# construct message
raw_tx_bytes = bfh(str(tx))
public_key = ecc.ECPubkey(K)
message = public_key.encrypt_message(raw_tx_bytes).decode(
'ascii')
# send message
server.put(_hash, message)
server.put(_hash + '_pick', 'True')
task = lambda: send_to_cosigner()
msg = _('Sending transaction to cosigning pool...')
WaitingDialog(self.window, msg, task, on_success, on_failure)
time.sleep(.5)
def prompt_user_for_otp(self, wallet, tx, on_success, on_failure):
if not isinstance(wallet, self.plugin.wallet_class):
return
if wallet.can_sign_without_server():
return
if not wallet.keystores['x3/'].get_tx_derivations(tx):
self.logger.info("twofactor: xpub3 not needed")
return
window = self.window.top_level_window()
auth_code = self.plugin.auth_dialog(window)
WaitingDialog(
parent=window,
message=_('Waiting for TrustedCoin server to sign transaction...'),
task=lambda: wallet.on_otp(tx, auth_code),
on_success=lambda *args: on_success(tx),
on_error=on_failure)
def _recv(self, parent):
def receiver_thread():
with self._audio_interface() as interface:
src = interface.recorder()
dst = BytesIO()
amodem.main.recv(config=self.modem_config, src=src, dst=dst)
return dst.getvalue()
def on_finished(blob):
if blob:
blob = zlib.decompress(blob).decode('ascii')
print_msg('Received:', repr(blob))
parent.setText(blob)
kbps = self.modem_config.modem_bps / 1e3
msg = 'Receiving from Audio MODEM ({0:.1f} kbps)...'.format(kbps)
WaitingDialog(parent, msg, receiver_thread, on_finished)
def waiting_dialog_for_billing_info(self, window, *, on_finished=None):
def task():
return self.request_billing_info(window.wallet,
suppress_connection_error=False)
def on_error(exc_info):
e = exc_info[1]
window.show_error("{header}\n{exc}\n\n{tor}".format(
header=_('Error getting TrustedCoin account info.'),
exc=str(e),
tor=
_('If you keep experiencing network problems, try using a Tor proxy.'
)))
return WaitingDialog(
parent=window,
message=_('Requesting account info from TrustedCoin server...'),
task=task,
on_success=on_finished,
on_error=on_error)
def do_send(self, tx, d):
def on_success(result):
window.show_message(_("Your transaction was sent to the cosigning pool.") + '\n' +
_("Open your cosigner wallet to retrieve it."))
time.sleep(1)
d.close()
def on_failure(exc_info):
e = exc_info[1]
try: self.logger.error("on_failure", exc_info=exc_info)
except OSError: pass
window.show_error(_("Failed to send transaction to cosigning pool") + ':\n' + str(e))
buffer = {'signed': [], 'txs': {}}
some_window = None
# construct messages
for window, xpub, K, _hash in self.cosigner_list:
if not self.cosigner_can_sign(tx, xpub):
continue
some_window = window
raw_tx_bytes = bfh(str(tx))
public_key = ecc.ECPubkey(K)
message = public_key.encrypt_message(raw_tx_bytes).decode('ascii')
buffer['txs'].update({_hash : message})
if not buffer:
return
# construct signed
if type(d) == TxDialogTimeout:
buffer['signed'] = d.signed
for key, _hash, window in self.keys:
buffer['signed'].append(_hash)
# send message
def send_messages_task():
server.put(self.wallet_hash, json.dumps(buffer))
msg = _('Sending transaction to cosigning pool...')
WaitingDialog(window, msg, send_messages_task, on_success, on_failure)
def waiting_dialog(self, window, on_finished=None):
task = partial(self.request_billing_info, window.wallet)
return WaitingDialog(window, 'Getting billing information...', task,
on_finished)