def updateHWstatus(self, ctrl):
if self.hwdevice is not None:
if hasattr(self.hwdevice, 'dongle'):
self.hwdevice.dongle.close()
self.hwdevice = HWdevice()
statusCode, statusMess = self.hwdevice.getStatus()
printDbg("mess: %s" % statusMess)
if statusCode != 2:
# If is not connected try again
try:
if hasattr(self.hwdevice, 'dongle'):
self.hwdevice.dongle.close()
self.hwdevice = HWdevice()
self.hwdevice.initDevice()
statusCode, statusMess = self.hwdevice.getStatus()
except Exception as e:
err_msg = "error in checkHw"
printException(getCallerName(), getFunctionName(), err_msg,
e.args)
self.hwStatus = statusCode
self.hwStatusMess = statusMess
def load_utxos_thread(self, ctrl):
self.apiConnected = False
try:
if not self.caller.rpcConnected:
self.rewards = []
printDbg('PIVX daemon not connected')
else:
try:
if self.apiClient.getStatus() != 200:
return
self.apiConnected = True
self.blockCount = self.caller.rpcClient.getBlockCount()
self.rewards = self.apiClient.getAddressUtxos(
self.curr_addr)['unspent_outputs']
for utxo in self.rewards:
self.rawtransactions[utxo[
'tx_hash']] = self.caller.rpcClient.getRawTransaction(
utxo['tx_hash'])
except Exception as e:
self.errorMsg = 'Error occurred while calling getaddressutxos method: ' + str(
e)
printDbg(self.errorMsg)
except Exception as e:
print(e)
pass
def addMasternode(self, mn, old_mn=None):
add_defaultKeys_to_dict(mn, DEFAULT_MN_CONF)
if not old_mn is None:
printDbg("DB: Editing masternode %s" % old_mn)
try:
cursor = self.getCursor()
cursor.execute(
"UPDATE MASTERNODES "
"SET name = ?, ip = ?, port = ?, mnPrivKey = ?, hwAcc = ?, isTestnet = ?, isHardware = ?,"
" address = ?, spath = ?, pubkey = ?, txid = ?, txidn = ?"
"WHERE name = ?",
(mn['name'], mn['ip'], mn['port'], mn['mnPrivKey'],
mn['hwAcc'], mn['isTestnet'],
1 if mn['isHardware'] else 0,
mn['collateral'].get('address'),
mn['collateral'].get('spath'),
mn['collateral'].get('pubKey'),
mn['collateral'].get('txid'),
mn['collateral'].get('txidn'), old_mn['name']))
except Exception as e:
err_msg = 'error writing masternode to DB'
printException(getCallerName(), getFunctionName(), err_msg,
e.args)
finally:
self.releaseCursor()
else:
# Add new record to the table
self.addNewMasternode(mn)
def scanForBip32(self, account, address, starting_spath=0, spath_count=10, isTestnet=False):
found = False
spath = -1
printOK("Scanning for Bip32 path of address: %s" % address)
for i in range(starting_spath, starting_spath+spath_count):
curr_path = MPATH + "%d'/0/%d" % (account, i)
printDbg("checking path... %s" % curr_path)
self.lock.acquire()
try:
if not isTestnet:
curr_addr = self.chip.getWalletPublicKey(curr_path).get('address')[12:-2]
else:
pubkey = compress_public_key(self.chip.getWalletPublicKey(curr_path).get('publicKey')).hex()
curr_addr = pubkey_to_address(pubkey, isTestnet)
if curr_addr == address:
found = True
spath = i
break
sleep(0.01)
except Exception as e:
err_msg = 'error in scanForBip32'
printException(getCallerName(), getFunctionName(), err_msg, e.args)
finally:
self.lock.release()
return (found, spath)
def FinishSend(self, serialized_tx, amount_to_send):
if not self.txFinished:
try:
self.txFinished = True
tx_hex = serialized_tx.hex()
printDbg("Raw signed transaction: " + tx_hex)
printDbg("Amount to send :" + amount_to_send)
if len(tx_hex) > 90000:
mess = "Transaction's length exceeds 90000 bytes. Select less UTXOs and try again."
self.caller.myPopUp2(QMessageBox.Warning, 'transaction Warning', mess)
else:
message = 'Broadcast signed transaction?<br><br>Destination address:<br><b>%s</b><br><br>' % (self.dest_addr)
message += 'Amount to send: <b>%s PIV</b><br>' % amount_to_send
message += 'Fee: <b>%s PIV</b><br>Size: <b>%d bytes</b>' % (str(round(self.currFee / 1e8, 8) ), len(tx_hex)/2)
reply = self.caller.myPopUp(QMessageBox.Information, 'Send transaction', message)
if reply == QMessageBox.Yes:
txid = self.caller.rpcClient.sendRawTransaction(tx_hex)
mess = QMessageBox(QMessageBox.Information, 'transaction Sent', 'transaction Sent')
mess.setDetailedText(txid)
mess.exec_()
else:
self.caller.myPopUp2(QMessageBox.Information, 'transaction NOT Sent', "transaction NOT sent")
self.onCancel()
except Exception as e:
err_msg = "Exception in sendRewards"
printException(getCallerName(), getFunctionName(), err_msg, e.args)
def onButtonSend(self):
try:
self.dest_addr = self.ui.edt_destination.text().strip()
if self.useSwiftX():
self.currFee = 0.01 * 1e8
else:
self.currFee = self.ui.feeLine.value() * 1e8
# Check RPC & dongle
if not self.main_tab.caller.rpcConnected or self.main_tab.caller.hwStatus != 2:
self.main_tab.caller.myPopUp2(QMessageBox.Critical, 'SPMT - hw/rpc device check', "Connect to RPC server and HW device first")
return None
# Check destination Address
if not checkPivxAddr(self.dest_addr):
self.main_tab.caller.myPopUp2(QMessageBox.Critical, 'SPMT - PIVX address check', "The destination address is missing, or invalid.")
return None
# LET'S GO
if len(self.rawtransactions) > 0:
printDbg("Preparing transaction. Please wait...")
self.ui.loadingLine.show()
self.ui.loadingLinePercent.show()
QApplication.processEvents()
# save last destination address and swiftxCheck to cache
self.main_tab.caller.parent.cache["lastAddress"] = self.dest_addr
self.main_tab.caller.parent.cache["useSwiftX"] = self.useSwiftX()
writeToFile(self.main_tab.caller.parent.cache, cache_File)
# re-connect signals
try:
self.main_tab.caller.hwdevice.sigTxdone.disconnect()
except:
pass
try:
self.main_tab.caller.hwdevice.sigTxabort.disconnect()
except:
pass
try:
self.main_tab.caller.hwdevice.tx_progress.disconnect()
except:
pass
self.main_tab.caller.hwdevice.sigTxdone.connect(self.FinishSend)
self.main_tab.caller.hwdevice.sigTxabort.connect(self.AbortSend)
self.main_tab.caller.hwdevice.tx_progress.connect(self.updateProgressPercent)
self.txFinished = False
self.main_tab.caller.hwdevice.prepare_transfer_tx_bulk(self.main_tab.caller, self.rewards, self.dest_addr, self.currFee, self.rawtransactions, self.useSwiftX())
else:
self.main_tab.caller.myPopUp2(QMessageBox.Information, 'Transaction NOT sent', "No UTXO to send")
except DisconnectedException as e:
self.main_tab.caller.hwStatus = 0
self.main_tab.caller.updateHWleds()
self.onButtonCancel()
except Exception as e:
err_msg = "Exception in onButtonSend"
printException(getCallerName(), getFunctionName(), err_msg, e.args)
def decodemasternodebroadcast(self, work):
printDbg("RPC: Decoding masternode broadcast...")
res = ""
with self.lock:
res = self.conn.decodemasternodebroadcast(work.strip())
return res
def getMasternodes(self):
printDbg("RPC: Getting masternode list...")
mnList = {}
score = []
masternodes = []
with self.lock:
masternodes = self.conn.listmasternodes()
for mn in masternodes:
if mn.get('status') == 'ENABLED':
# compute masternode score
if mn.get('lastpaid') == 0:
mn['score'] = mn.get('activetime')
else:
lastpaid_ago = now() - mn.get('lastpaid')
mn['score'] = min(lastpaid_ago, mn.get('activetime'))
else:
mn['score'] = 0
score.append(mn)
# sort masternodes by decreasing score
score.sort(key=lambda x: x['score'], reverse=True)
# save masternode position in the payment queue
for mn in masternodes:
mn['queue_pos'] = score.index(mn)
mnList['masternodes'] = masternodes
return mnList
def relaymasternodebroadcast(self, work):
printDbg("RPC: Relaying masternode broadcast...")
res = ""
with self.lock:
res = self.conn.relaymasternodebroadcast(work.strip())
return res
def displayMNlistUpdated(self):
for masternode in self.caller.masternode_list:
printDbg(
"Checking %s (%s)..." %
(masternode['name'], masternode['collateral'].get('txid')))
self.displayMNStatus(masternode)
time.sleep(0.1)
def initDevice(self):
printDbg("Initializing Trezor")
with self.lock:
self.status = 0
devices = enumerate_devices()
if not len(devices):
# No device connected
return
# Use the first device for now
d = devices[0]
ui = TrezorUi()
try:
self.client = TrezorClient(d, ui)
except IOError:
raise Exception("TREZOR device is currently in use")
printOK("Trezor HW device connected [v. %s.%s.%s]" %
(self.client.features.major_version,
self.client.features.minor_version,
self.client.features.patch_version))
self.status = 1
model = self.client.features.model or "1"
if not self.checkModel(model):
self.status = 3
self.messages[
3] = "Wrong device model (%s) detected.\nLooking for model %s." % (
HW_devices[self.model][0], model)
return
required_version = MINIMUM_FIRMWARE_VERSION[model]
printDbg("Current version is %s (minimum required: %s)" %
(str(self.client.version), str(required_version)))
# Check device is unlocked
bip32_path = parse_path(MPATH + "%d'/0/%d" % (0, 0))
_ = btc.get_address(self.client, 'PIVX', bip32_path, False)
self.status = 2
def initTables(self):
printDbg("DB: Initializing tables...")
try:
cursor = self.conn.cursor()
# Tables for RPC Servers
cursor.execute("CREATE TABLE IF NOT EXISTS PUBLIC_RPC_SERVERS("
" id INTEGER PRIMARY KEY, protocol TEXT, host TEXT,"
" user TEXT, pass TEXT)")
cursor.execute("CREATE TABLE IF NOT EXISTS CUSTOM_RPC_SERVERS("
" id INTEGER PRIMARY KEY, protocol TEXT, host TEXT,"
" user TEXT, pass TEXT)")
self.initTable_RPC(cursor)
# Tables for Utxos
cursor.execute(
"CREATE TABLE IF NOT EXISTS UTXOS("
" tx_hash TEXT, tx_ouput_n INTEGER, satoshis INTEGER, confirmations INTEGER,"
" script TEXT, raw_tx TEXT, receiver TEXT, staker TEXT, coinstake BOOLEAN,"
" PRIMARY KEY (tx_hash, tx_ouput_n))")
printDbg("DB: Tables initialized")
except Exception as e:
err_msg = 'error initializing tables'
printException(getCallerName(), getFunctionName(), err_msg, e.args)
def onStartMN(self, data=None):
# Check RPC & dongle
if not self.caller.rpcConnected or self.caller.hwStatus != 2:
self.caller.myPopUp2(QMessageBox.Critical,
'SPMT - hw/rpc device check',
"Connect to RPC server and HW device first")
printDbg("Hardware device or RPC server not connected")
return None
try:
if not data:
target = self.ui.sender()
masternode_alias = target.alias
printOK("Start-masternode %s pressed" % masternode_alias)
for mn_conf in self.caller.masternode_list:
if mn_conf['name'] == masternode_alias:
reply = self.caller.myPopUp(
QMessageBox.Question, 'Confirm START',
"Are you sure you want to start masternoode:\n'%s'?"
% mn_conf['name'], QMessageBox.Yes)
if reply == QMessageBox.Yes:
self.masternodeToStart = Masternode(
self, mn_conf['name'], mn_conf['ip'],
mn_conf['port'], mn_conf['mnPrivKey'],
mn_conf['hwAcc'], mn_conf['collateral'])
# connect signal
self.masternodeToStart.sigdone.connect(
self.sendBroadcast)
self.mnToStartList.append(self.masternodeToStart)
self.startMN()
break
except Exception as e:
err_msg = "error before starting node"
printException(getCallerName(), getFunctionName(), err_msg, e)
def onStartAllMN(self):
printOK("Start-All pressed")
# Check RPC & dongle
if not self.caller.rpcConnected:
self.caller.myPopUp2(QMessageBox.Critical,
'QMT - hw/rpc device check',
"Connect to RPC server and HW device first")
printDbg("Hardware device or RPC server not connected")
return None
try:
reply = self.caller.myPopUp(
QMessageBox.Question, 'Confirm START',
"Are you sure you want to start ALL masternodes?",
QMessageBox.Yes)
if reply == QMessageBox.Yes:
mnList = [
x for x in self.caller.masternode_list if x['isHardware']
]
for mn_conf in mnList:
self.masternodeToStart = Masternode(
self, mn_conf['name'], mn_conf['ip'], mn_conf['port'],
mn_conf['mnPrivKey'], mn_conf['hwAcc'],
mn_conf['collateral'])
# connect signal
self.masternodeToStart.sigdone.connect(self.sendBroadcast)
self.mnToStartList.append(self.masternodeToStart)
self.startMN()
except Exception as e:
err_msg = "error before starting node"
printException(getCallerName(), getFunctionName(), err_msg, e)
def onButtonSave(self, main_dlg):
main_dlg.rpc_ip = ip_address(self.edt_rpcIp.text().strip()).compressed
main_dlg.rpc_port = int(self.edt_rpcPort.value())
main_dlg.rpc_user = self.edt_rpcUser.text()
main_dlg.rpc_password = self.edt_rpcPassword.text()
conf = {}
conf["rpc_ip"] = main_dlg.rpc_ip
conf["rpc_port"] = main_dlg.rpc_port
conf["rpc_user"] = main_dlg.rpc_user
conf["rpc_password"] = main_dlg.rpc_password
urlstring = "http://%s:%s@%s:%d" % (conf["rpc_user"],
conf["rpc_password"],
conf["rpc_ip"], conf["rpc_port"])
if checkRPCstring(urlstring,
action_msg="Restoring previous configuration"):
# Update datafile
writeToFile(conf, rpc_File)
# Update current RPC Server
main_dlg.main_wnd.mainWindow.rpcClient = None
main_dlg.main_wnd.mainWindow.rpcConnected = False
printDbg("Trying to connect to RPC server [%s]:%s" %
(conf["rpc_ip"], str(conf["rpc_port"])))
self.runInThread = ThreadFuns.runInThread(
main_dlg.main_wnd.mainWindow.updateRPCstatus, (),
main_dlg.main_wnd.mainWindow.updateRPCled)
else:
printDbg("Restored RPC credentials. ")
main_dlg.close()
def append_inputs_to_TX(self, utxo, bip32_path):
self.amount += int(utxo['value'])
raw_tx = bytearray.fromhex(utxo['raw_tx'])
# parse the raw transaction, so that we can extract the UTXO locking script we refer to
prev_transaction = bitcoinTransaction(raw_tx)
utxo_tx_index = utxo['tx_ouput_n']
if utxo_tx_index < 0 or utxo_tx_index > len(prev_transaction.outputs):
raise Exception('Incorrect value of outputIndex for UTXO %s-%d' %
(utxo['raw_tx'], utxo['tx_ouput_n']))
trusted_input = self.chip.getTrustedInput(prev_transaction, utxo_tx_index)
self.trusted_inputs.append(trusted_input)
# Hash check
curr_pubkey = compress_public_key(self.chip.getWalletPublicKey(bip32_path)['publicKey'])
pubkey_hash = bin_hash160(curr_pubkey)
pubkey_hash_from_script = extract_pkh_from_locking_script(prev_transaction.outputs[utxo_tx_index].script)
if pubkey_hash != pubkey_hash_from_script:
text = "Error: The hashes for the public key for the BIP32 path, and the UTXO locking script do not match."
text += "Your signed transaction will not be validated by the network.\n"
text += "pubkey_hash: %s\n" % pubkey_hash.hex()
text += "pubkey_hash_from_script: %s\n" % pubkey_hash_from_script.hex()
printDbg(text)
self.arg_inputs.append({
'locking_script': prev_transaction.outputs[utxo['tx_ouput_n']].script,
'pubkey': curr_pubkey,
'bip32_path': bip32_path,
'outputIndex': utxo['tx_ouput_n'],
'txid': utxo['tx_hash']
})
def findPubKey(self):
printDbg("Computing public key...")
currSpath = self.ui.edt_spath.value()
currHwAcc = self.ui.edt_hwAccount.value()
# Check HW device
if self.caller.hwStatus != 2:
myPopUp_sb(self.caller, "crit", 'SPMT - hw device check', "Connect to HW device first")
printDbg("Unable to connect to hardware device. The device status is: %d" % self.caller.hwStatus)
return None
result = self.caller.hwdevice.scanForPubKey(currHwAcc, currSpath, self.isTestnet())
# Connection pop-up
warningText = "Unable to find public key. The action was refused on the device or another application "
warningText += "might have taken over the USB communication with the device.<br><br>"
warningText += "To continue click the <b>Retry</b> button.\nTo cancel, click the <b>Abort</b> button."
mBox = QMessageBox(QMessageBox.Critical, "WARNING", warningText, QMessageBox.Retry)
mBox.setStandardButtons(QMessageBox.Retry | QMessageBox.Abort);
while result is None:
ans = mBox.exec_()
if ans == QMessageBox.Abort:
return
# we need to reconnect the device
self.caller.hwdevice.clearDevice()
self.caller.hwdevice.initDevice(self.caller.header.hwDevices.currentIndex())
result = self.caller.hwdevice.scanForPubKey(currHwAcc, currSpath, self.isTestnet())
mess = "Found public key:\n%s" % result
myPopUp_sb(self.caller, "info", "SPMT - findPubKey", mess)
printOK("Public Key: %s" % result)
self.ui.edt_pubKey.setText(result)
def load_utxos_thread(self, ctrl):
self.apiConnected = False
try:
if not self.rpcClient.getStatus():
printDbg('PIVX daemon not connected')
else:
try:
if self.apiClient.getStatus() != 200:
return
self.apiConnected = True
self.blockCount = self.rpcClient.getBlockCount()
utxos = self.apiClient.getAddressUtxos(
self.pivx_addr)['unspent_outputs']
printDbg("loading utxos\nblockCount=%s\n%s" %
(str(self.blockCount), str(self.utxos)))
self.utxos = [
utxo for utxo in utxos
if round(int(utxo.get('value', 0)) /
1e8, 8) == 10000.00000000
]
except Exception as e:
self.errorMsg = 'Error occurred while calling getaddressutxos method: ' + str(
e)
print(self.errorMsg)
except Exception as e:
print(e)
pass
def updateHWstatus(self, ctrl):
if self.hwdevice is not None:
if hasattr(self.hwdevice, 'dongle'):
self.hwdevice.dongle.close()
self.hwdevice = HWdevice()
statusCode, statusMess = self.hwdevice.getStatus()
printDbg("mess: %s" % statusMess)
if statusCode != 2:
# If is not connected try again
try:
if hasattr(self.hwdevice, 'dongle'):
self.hwdevice.dongle.close()
self.hwdevice = HWdevice()
self.hwdevice.initDevice()
statusCode, statusMess = self.hwdevice.getStatus()
except Exception as e:
err_msg = "error in checkHw"
printException(getCallerName(), getFunctionName(), err_msg, e.args)
self.hwStatus = statusCode
self.hwStatusMess = statusMess
# if all is good connect the signals
if statusCode == 2:
self.hwdevice.sigTxdone.connect(self.t_rewards.FinishSend)
self.hwdevice.sigTxabort.connect(self.t_rewards.onCancel)
self.hwdevice.tx_progress.connect(self.t_rewards.updateProgressPercent)
def getStatus(self):
status = False
statusMess = "Unable to connect to a PIVX RPC server.\n"
statusMess += "Either the local PIVX wallet is not open, or the remote RPC server is not responding."
n = 0
try:
self.lock.acquire()
n = self.conn.getblockcount()
if n > 0:
status = True
statusMess = "Connected to PIVX RPC client"
except Exception as e:
# If loading block index set lastBlock=1
if str(e.args[0]) == "Loading block index..." or str(
e.args[0]) == "Verifying blocks...":
printDbg(str(e.args[0]))
statusMess = "PIVX wallet is connected but still synchronizing / verifying blocks"
n = 1
elif str(e.args[0]) != "Request-sent" and str(
e.args[0]) != "10061":
err_msg = "Error while contacting RPC server"
printException(getCallerName(), getFunctionName(), err_msg,
e.args)
finally:
self.lock.release()
return status, statusMess, n
def onButtonSave(self, main_dlg):
try:
main_dlg.rpc_ip = ip_address(
self.edt_rpcIp.text().strip()).compressed
main_dlg.rpc_port = int(self.edt_rpcPort.value())
main_dlg.rpc_user = self.edt_rpcUser.text()
main_dlg.rpc_password = self.edt_rpcPassword.text()
conf = {}
conf["rpc_ip"] = main_dlg.rpc_ip
conf["rpc_port"] = main_dlg.rpc_port
conf["rpc_user"] = main_dlg.rpc_user
conf["rpc_password"] = main_dlg.rpc_password
# Update File
writeRPCfile(conf)
# Update current RPC Server
main_dlg.main_wnd.mainWindow.rpcClient = None
main_dlg.main_wnd.mainWindow.rpcConnected = False
printDbg("Trying to connect to RPC server [%s]:%s" %
(conf["rpc_ip"], str(conf["rpc_port"])))
self.runInThread = ThreadFuns.runInThread(
main_dlg.main_wnd.mainWindow.updateRPCstatus, (),
main_dlg.main_wnd.mainWindow.updateRPCled)
main_dlg.close()
except Exception as e:
print(e)
def verifyMessage(self, pivxaddress, signature, message):
printDbg("RPC: Verifying message...")
res = False
with self.lock:
res = self.conn.verifymessage(pivxaddress, signature, message)
return res
def initTables(self):
printDbg("DB: Initializing tables...")
try:
cursor = self.conn.cursor()
# Tables for RPC Servers
cursor.execute("CREATE TABLE IF NOT EXISTS PUBLIC_RPC_SERVERS("
" id INTEGER PRIMARY KEY, protocol TEXT, host TEXT,"
" user TEXT, pass TEXT)")
cursor.execute("CREATE TABLE IF NOT EXISTS CUSTOM_RPC_SERVERS("
" id INTEGER PRIMARY KEY, protocol TEXT, host TEXT,"
" user TEXT, pass TEXT)")
self.initTable_RPC(cursor)
# Tables for Masternodes
cursor.execute(
"CREATE TABLE IF NOT EXISTS MASTERNODES("
" name TEXT PRIMARY KEY, ip TEXT, port INTEGER, mnPrivKey TEXT,"
" hwAcc INTEGER, isTestnet INTEGER, isHardware INTEGER,"
" address TEXT, spath INTEGER, pubkey TEXT, txid TEXT, txidn INTEGER)"
)
# Tables for Rewards
cursor.execute(
"CREATE TABLE IF NOT EXISTS REWARDS("
" tx_hash TEXT, tx_ouput_n INTEGER,"
" satoshis INTEGER, confirmations INTEGER, script TEXT, mn_name TEXT, coinstake BOOLEAN,"
" staker TEXT,"
" PRIMARY KEY (tx_hash, tx_ouput_n))")
cursor.execute(
"CREATE TABLE IF NOT EXISTS RAWTXES("
" tx_hash TEXT PRIMARY KEY, rawtx TEXT, lastfetch INTEGER)")
# Tables for Governance Objects
cursor.execute(
"CREATE TABLE IF NOT EXISTS PROPOSALS("
" name TEXT, url TEXT, hash TEXT PRIMARY KEY, feeHash TEXT,"
" blockStart INTEGER, blockEnd INTEGER, totalPayCount INTEGER,"
" remainingPayCount INTEGER, paymentAddress TEXT,"
" yeas INTEGER, nays INTEGER, abstains INTEGER, "
" totalPayment REAL, monthlyPayment REAL)")
#cursor.execute("CREATE TABLE IF NOT EXISTS PROJECTED_PROPOSALS("
# " name TEXT, hash TEXT PRIMARY KEY, "
# " allotted REAL, votes INTEGER, totaAllotted REAL)")
cursor.execute(
"CREATE TABLE IF NOT EXISTS MY_VOTES("
" mn_name TEXT, p_hash, vote INTEGER, timeslip INTEGER, "
" PRIMARY KEY (mn_name, p_hash))")
printDbg("DB: Tables initialized")
except Exception as e:
err_msg = 'error initializing tables'
printException(getCallerName(), getFunctionName(), err_msg, e.args)
def __init__(self, *args, **kwargs):
QObject.__init__(self, *args, **kwargs)
# Device Lock for threads
self.lock = threading.Lock()
printDbg("Creating HW device class")
self.initDevice()
# Connect signal
self.sig_progress.connect(self.updateSigProgress)
def __init__(self, app):
printDbg("DB: Initializing...")
self.app = app
self.file_name = database_File
self.lock = threading.Lock()
self.isOpen = False
self.conn = None
printDbg("DB: Initialized")
def onEditRPCServer(self):
# Create Dialog
try:
ui = ConfigureRPCserver_dlg(self)
if ui.exec():
printDbg("Configuring RPC Server...")
except Exception as e:
print(e)
def __init__(self, *args, **kwargs):
QObject.__init__(self, *args, **kwargs)
# Device Lock for threads
self.lock = threading.RLock()
self.status = 0
self.dongle = None
printDbg("Creating HW device class")
# Connect signal
self.sig_progress.connect(self.updateSigProgress)
def sendRawTransaction(self, tx_hex):
dbg_mess = "RPC: Sending raw transaction"
dbg_mess += "..."
printDbg(dbg_mess)
tx_id = None
with self.lock:
tx_id = self.conn.sendrawtransaction(tx_hex, True)
return tx_id
def startMN(self):
if self.caller.hwStatus != 2:
myPopUp_sb(self.caller, "warn", 'SPMT - hw device check', self.caller.hwStatusMess)
elif not self.caller.rpcConnected:
myPopUp_sb(self.caller, "warn", 'SPMT - rpc device check', self.caller.rpcStatusMess)
else:
self.masternodeToStart = self.mnToStartList.pop()
printDbg("Starting...%s" % self.masternodeToStart.name)
self.masternodeToStart.startMessage(self.caller.hwdevice, self.caller.rpcClient)
def addressToSpath(self):
printOK("addressToSpath pressed")
self.spath_found = False
# Check HW device
if self.caller.hwStatus != 2:
myPopUp_sb(self.caller, "crit", 'SPMT - hw device check', "Connect to HW device first")
printDbg("Unable to connect to hardware device. The device status is: %d" % self.caller.hwStatus)
return None
self.runInThread(self.findSpath, (0, 10), self.findSpath_done)
