Beispiel #1
0
    def getBudgetVotes(self, proposal):
        try:
            self.lock.acquire()
            votes = self.conn.getbudgetvotes(proposal)
        except Exception as e:
            err_msg = 'remote or local PIVX-cli running?'
            printException(getCallerName(), getFunctionName(), err_msg, e.args)
            votes = {}
        finally:
            self.lock.release()

        return votes
Beispiel #2
0
    def getAddressUtxos(self, addresses):
        try:
            self.lock.acquire()
            res = self.conn.getaddressutxos({'addresses': addresses})
        except Exception as e:
            err_msg = "error in getAddressUtxos"
            printException(getCallerName(), getFunctionName(), err_msg, e.args)
            res = None
        finally:
            self.lock.release()

        return res
Beispiel #3
0
    def relaymasternodebroadcast(self, work):
        try:
            self.lock.acquire()
            res = self.conn.relaymasternodebroadcast(work.strip())
        except Exception as e:
            err_msg = "error in relaymasternodebroadcast"
            printException(getCallerName(), getFunctionName(), err_msg, e.args)
            res = ""
        finally:
            self.lock.release()

        return res
Beispiel #4
0
    def verifyMessage(self, pivxaddress, signature, message):
        try:
            self.lock.acquire()
            res = self.conn.verifymessage(pivxaddress, signature, message)
        except Exception as e:
            err_msg = "error in verifyMessage"
            printException(getCallerName(), getFunctionName(), err_msg, e.args)
            res = False
        finally:
            self.lock.release()

        return res
Beispiel #5
0
    def decodeRawTransaction(self, rawTx):
        try:
            self.lock.acquire()
            res = self.conn.decoderawtransaction(rawTx)
        except Exception as e:
            err_msg = 'error in decodeRawTransaction'
            printException(getCallerName(), getFunctionName(), err_msg, e.args)
            res = None
        finally:
            self.lock.release()

        return res
Beispiel #6
0
    def getRawTransaction(self, txid):
        try:
            self.lock.acquire()
            res = self.conn.getrawtransaction(txid)
        except Exception as e:
            err_msg = "is Blockchain synced?"
            printException(getCallerName(), getFunctionName(), err_msg, e.args)
            res = None
        finally:
            self.lock.release()

        return res
Beispiel #7
0
    def getMasternodeCount(self):
        try:
            self.lock.acquire()
            ans = self.conn.getmasternodecount()
        except Exception as e:
            err_msg = "error in getMasternodeCount"
            printException(getCallerName(), getFunctionName(), err_msg, e.args)
            ans = None
        finally:
            self.lock.release()

        return ans
Beispiel #8
0
    def deleteReward(self, txid, txidn):
        try:
            cursor = self.getCursor()
            cursor.execute(
                "DELETE FROM REWARDS WHERE tx_hash = ? AND tx_ouput_n = ?",
                (txid, txidn))

        except Exception as e:
            err_msg = 'error deleting UTXO from DB'
            printException(getCallerName(), getFunctionName(), err_msg, e.args)
        finally:
            self.releaseCursor(vacuum=True)
Beispiel #9
0
    def getBlockHash(self, blockNum):
        try:
            self.lock.acquire()
            h = self.conn.getblockhash(blockNum)
        except Exception as e:
            err_msg = 'remote or local PIVX-cli running?'
            printException(getCallerName(), getFunctionName(), err_msg, e.args)
            h = None
        finally:
            self.lock.release()

        return h
Beispiel #10
0
 def getBlockCount(self):
     try:
         self.parameters = {}
         self.parameters['q'] = 'getblockcount'
         return self.checkResponse(self.parameters)
     except Exception as e:
         err_msg = "error in getBlockCount"
         printException(getCallerName(), getFunctionName(), err_msg, e.args)
         try:
             self.client.close()
             self.client = requests.session()
         except Exception:
             pass
Beispiel #11
0
    def process_ledger_exceptions_int(*args, **kwargs):
        hwDevice = args[0]
        try:
            return func(*args, **kwargs)

        except BTChipException as e:
            printDbg('Error while communicating with Ledger hardware wallet.')
            e.message = 'Error while communicating with Ledger hardware wallet.'
            if (e.sw in (0x6f01, 0x6d00, 0x6700, 0x6faa)):
                e.message = 'Make sure the PIVX app is open on your Ledger device.'
                e.message += '<br>If there is a program (such as Ledger Bitcoin Wallet) interfering with the USB communication, close it first.'
            elif (e.sw == 0x6982):
                e.message = 'Enter the PIN on your Ledger device.'
            printException(getCallerName(True), getFunctionName(True), e.message, e.args)
            raise DisconnectedException(e.message, hwDevice)

        except Exception as e:
            e.message = "Ledger - generic exception"
            if str(e.args[0]) == 'read error':
                e.message = 'Read Error. Click "Connect" to reconnect HW device'
            printException(getCallerName(True), getFunctionName(True), e.message, str(e))
            raise DisconnectedException(e.message, hwDevice)
Beispiel #12
0
 def signature1(self, device):
     self.sig_time = int(time.time())
     serializedData = ipport(self.ip, self.port)
     serializedData += str(self.sig_time)
     serializedData += binascii.unhexlify(
         bitcoin.hash160(bytes.fromhex(
             self.collateral['pubKey'])))[::-1].hex()
     serializedData += binascii.unhexlify(
         bitcoin.hash160(bytes.fromhex(self.mnPubKey)))[::-1].hex()
     serializedData += str(self.protocol_version)
     printDbg("Masternode PubKey: %s" % self.mnPubKey)
     printDbg("SerializedData: MY_IP:%s" % serializedData.split(':')[1])
     try:
         device.signMess(self.caller, self.nodePath, serializedData)
         #wait for signal when device.sig1 is ready then --> finalizeStartMessage
     except Exception as e:
         err_msg = "error in signature1"
         printException(getCallerName(), getFunctionName(), err_msg, e.args)
     except KeyboardInterrupt:
         err_msg = "Keyboard Interrupt"
         printException(getCallerName(), getFunctionName(), err_msg, e.args)
     return None
Beispiel #13
0
    def process_RPC_exceptions_int(*args, **kwargs):
        try:
            return func(*args, **kwargs)

        except Exception as e:
            message = "Exception in RPC client"
            printException(getCallerName(True), getFunctionName(True), message,
                           e)
            try:
                args[0].httpConnection.close()
            except Exception as e:
                printDbg(e)
                pass
Beispiel #14
0
    def scanForPubKey(self, account, spath):
        printOK("Scanning for Address of path_id %s on account n° %s" %
                (str(spath), str(account)))
        curr_path = MPATH + "%d'/0/%d" % (account, spath)
        try:
            nodeData = self.chip.getWalletPublicKey(curr_path)

        except Exception as e:
            err_msg = 'error in scanForPubKey'
            printException(getCallerName(), getFunctionName(), err_msg, e.args)
            return None

        return compress_public_key(nodeData.get('publicKey')).hex()
Beispiel #15
0
    def sendRawTransaction(self, tx_hex, use_swiftx):
        try:
            self.lock.acquire()
            tx_id = self.conn.sendrawtransaction(tx_hex, True,
                                                 bool(use_swiftx))
        except Exception as e:
            err_msg = 'error in rpcClient.sendRawTransaction'
            printException(getCallerName(), getFunctionName(), err_msg, e.args)
            tx_id = None
        finally:
            self.lock.release()

        return tx_id
Beispiel #16
0
    def getProtocolVersion(self):
        try:
            self.lock.acquire()
            prot_version = self.conn.getinfo().get('protocolversion')
            res = int(prot_version)
        except Exception as e:
            err_msg = 'error in getProtocolVersion'
            printException(getCallerName(), getFunctionName(), err_msg, e.args)
            res = DEFAULT_PROTOCOL_VERSION
        finally:
            self.lock.release()

        return res
Beispiel #17
0
    def removeTable(self, table_name):
        printDbg("DB: Dropping table %s..." % table_name)
        try:
            cursor = self.getCursor()
            cursor.execute("DROP TABLE IF EXISTS %s" % table_name)
            printDbg("DB: Table %s removed" % table_name)

        except Exception as e:
            err_msg = 'error removing table %s from database' % table_name
            printException(getCallerName(), getFunctionName(), err_msg, e.args)

        finally:
            self.releaseCursor(vacuum=True)
Beispiel #18
0
    def initTables(self):
        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,"
                " value INTEGER, confirmations INTEGER, script TEXT, raw_tx TEXT, mn_name TEXT,"
                " PRIMARY KEY (tx_hash, tx_ouput_n))")

            # 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))")

        except Exception as e:
            err_msg = 'error initializing tables'
            printException(getCallerName(), getFunctionName(), err_msg, e.args)
Beispiel #19
0
    def FinishSend(self, serialized_tx, amount_to_send):
        self.AbortSend()
        QApplication.processEvents()
        if not self.txFinished:
            try:
                self.txFinished = True
                self.close()
                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.main_tab.caller.myPopUp2(QMessageBox.Warning,
                                                  'transaction Warning', mess)

                else:
                    decodedTx = self.main_tab.caller.rpcClient.decodeRawTransaction(
                        tx_hex)
                    destination = decodedTx.get("vout")[0].get(
                        "scriptPubKey").get("addresses")[0]
                    amount = decodedTx.get("vout")[0].get("value")
                    message = '<p>Broadcast signed transaction?</p><p>Destination address:<br><b>%s</b></p>' % destination
                    message += '<p>Amount: <b>%s</b> QMC<br>' % str(amount)
                    message += 'Fees: <b>%s</b> QMC <br>Size: <b>%d</b> Bytes</p>' % (
                        str(round(self.currFee / 1e8, 8)), len(tx_hex) / 2)

                    mess1 = QMessageBox(QMessageBox.Information,
                                        'Send transaction', message)
                    mess1.setDetailedText(
                        json.dumps(decodedTx, indent=4, sort_keys=False))
                    mess1.setStandardButtons(QMessageBox.Yes | QMessageBox.No)
                    reply = mess1.exec_()
                    if reply == QMessageBox.Yes:
                        txid = self.main_tab.caller.rpcClient.sendRawTransaction(
                            tx_hex, self.useSwiftX())
                        mess2_text = "<p>Transaction successfully sent.</p><p>(Note that the selected rewards will remain displayed in the app until the transaction is confirmed.)</p>"
                        mess2 = QMessageBox(QMessageBox.Information,
                                            'transaction Sent', mess2_text)
                        mess2.setDetailedText(txid)
                        mess2.exec_()

                    else:
                        self.main_tab.caller.myPopUp2(QMessageBox.Information,
                                                      'Transaction NOT sent',
                                                      "Transaction NOT sent")

            except Exception as e:
                err_msg = "Exception in FinishSend"
                printException(getCallerName(), getFunctionName(), err_msg,
                               e.args)
Beispiel #20
0
    def submit_torrent_thread(self, ctrl, name, uri, payee, cat):
        while not self.update:
            time.sleep(self.UPDATE_HALF_PERIOD)

        with requests.Session() as s:
            initial_block = self.current_block

            response = None
            try:
                response = s.post(self.server_uri,
                                  auth=self.auth_pair,
                                  data=self.prepare_budget_json(
                                      name, uri, payee, cat, self.next_super),
                                  headers={'Content-Type': 'text/plain'})
            except Exception as e:
                printException(getCallerName(), getFunctionName(),
                               'Preparing the torrent failed',
                               e.args + (name, uri, payee, cat))

            response_object = json.loads(response.content)

            if response_object.get('error'):
                raise ValueError(response_object['error']['message'])

            while self.current_block < initial_block + self.BLOCK_DELAY:
                time.sleep(self.UPDATE_HALF_PERIOD)

            try:
                s.post(self.server_uri,
                       auth=self.auth_pair,
                       data=self.submit_budget_json(name, uri, payee, cat,
                                                    self.next_super,
                                                    response_object['result']),
                       headers={'Content-Type': 'text/plain'})
            except Exception as e:
                printException(getCallerName(), getFunctionName(),
                               'Submitting the torrent failed',
                               e.args + (name, uri, payee, cat))
Beispiel #21
0
 def getStatusCode(self):
     try:
         if self.initialized:
             if not self.checkApp():
                 statusCode = 1
             else:
                 statusCode = 2
         else:
             statusCode = 0
     except Exception as e:
         err_msg = 'error in getStatusCode'
         printException(getCallerName(), getFunctionName(), err_msg, e.args)
         statusCode = 0
     return statusCode
Beispiel #22
0
    def signTxSign(self, ctrl):
        self.lock.acquire()
        try:
            starting = True
            curr_input_signed = 0
            # sign all inputs on Ledger and add inputs in the self.new_transaction object for serialization
            for idx, new_input in enumerate(self.arg_inputs):
                   
                self.chip.startUntrustedTransaction(starting, idx, self.trusted_inputs, new_input['locking_script'])
                 
                self.chip.finalizeInputFull(self.all_outputs_raw)
                
                sig = self.chip.untrustedHashSign(new_input['bip32_path'], lockTime=0)
                
                new_input['signature'] = sig
                inputTx = bitcoinInput()
                inputTx.prevOut = bytearray.fromhex(new_input['txid'])[::-1] + int.to_bytes(new_input['outputIndex'], 4, byteorder='little')
                
                inputTx.script = bytearray([len(sig)]) + sig + bytearray([0x21]) + new_input['pubkey']

                inputTx.sequence = bytearray([0xFF, 0xFF, 0xFF, 0xFF])
                
                self.new_transaction.inputs.append(inputTx)

                starting = False
                
                # signature percent emitted
                curr_input_signed += 1
                completion = int(100*curr_input_signed / len(self.arg_inputs))
                self.sig_progress.emit(completion)
                
            self.new_transaction.lockTime = bytearray([0, 0, 0, 0])
            self.tx_raw = bytearray(self.new_transaction.serialize())
            self.sig_progress.emit(100)
            
        except TypeError as te:
            printDbg(str(te))
            self.tx_raw = None
            
        except Exception as e:
            if e.sw != 0x6985:
                self.status = 0
                printException(getCallerName(), getFunctionName(), e.message, e.args)            
            self.tx_raw = None
            
        finally:
            self.lock.release()
            if self.status == 0:
                self.dongle.close()
                self.initDevice()
Beispiel #23
0
 def append_inputs_to_TX(self, utxo, bip32_path, inputs):
     if utxo['staker'] != "":
         printException(getCallerName(), getFunctionName(),
                        "Unable to sing P2CS on Trezor", "")
         return
     # Update amount
     self.amount += int(utxo['satoshis'])
     # Add input
     address_n = parse_path(bip32_path)
     prev_hash = binascii.unhexlify(utxo['txid'])
     it = trezor_proto.TxInputType(address_n=address_n,
                                   prev_hash=prev_hash,
                                   prev_index=int(utxo['vout']))
     inputs.append(it)
Beispiel #24
0
 def getBalance(self, address):
     try:
         self.parameters = {}
         self.parameters['q'] = 'getbalance'
         self.parameters['a'] = address
         return self.checkResponse(self.parameters)
     except Exception as e:
         err_msg = "error in getBalance"
         printException(getCallerName(), getFunctionName(), err_msg, e.args)
         try:
             self.client.close()
             self.client = requests.session()
         except Exception:
             pass
Beispiel #25
0
 def startMN(self):       
     if self.caller.hwStatus != 2:
         self.caller.myPopUp2(QMessageBox.Question, 'SPMT - hw device check', self.caller.hwStatusMess, QMessageBox.Ok)
     elif not self.caller.rpcConnected:
         self.caller.myPopUp2(QMessageBox.Question, 'SPMT - rpc device check', self.caller.rpcStatusMess, QMessageBox.Ok)
     else:           
         try:
             self.masternodeToStart = self.mnToStartList.pop()
             printDbg("Starting...%s" % self.masternodeToStart.name)
             self.masternodeToStart.startMessage(self.caller.hwdevice, self.caller.rpcClient)
             # wait for signal when masternode.work is ready then ---> sendBroadcast
         except Exception as e:
             err_msg = "error in startMN"
             printException(getCallerName(), getFunctionName(), err_msg, e)
Beispiel #26
0
 def getBlockHash(self, blockNum):
     try:
         self.parameters = {}
         self.parameters['q'] = 'getblockhash'
         self.parameters['height'] = str(blockNum)
         return self.checkResponse(self.parameters)
     except Exception as e:
         err_msg = "error in getBlockHash"
         printException(getCallerName(), getFunctionName(), err_msg, e.args)
         try:
             self.client.close()
             self.client = requests.session()
         except Exception:
             pass
Beispiel #27
0
    def clearRawTxes(self, minTime):
        """
        removes txes with lastfetch older than mintime
        """
        printDbg("Pruning table RAWTXES")
        try:
            cursor = self.getCursor()
            cursor.execute("DELETE FROM RAWTXES WHERE lastfetch < ?", (minTime,))

        except Exception as e:
            err_msg = 'error deleting rawtx from DB'
            printException(getCallerName(), getFunctionName(), err_msg, e.args)
        finally:
            self.releaseCursor(vacuum=True)
Beispiel #28
0
    def getFeePerKb(self):
        try:
            self.lock.acquire()
            # get transaction data from last 200 blocks
            feePerKb = float(self.conn.getfeeinfo(200)['feeperkb'])
            res = (feePerKb if feePerKb > MINIMUM_FEE else MINIMUM_FEE)
        except Exception as e:
            err_msg = 'error in getFeePerKb'
            printException(getCallerName(), getFunctionName(), err_msg, e.args)
            res = MINIMUM_FEE
        finally:
            self.lock.release()

        return res
Beispiel #29
0
    def getBlockCount(self):
        try:
            self.lock.acquire()
            n = self.conn.getblockcount()
        except Exception as e:
            err_msg = 'remote or local PIVX-cli running?'
            if str(e.args[0]) != "Request-sent":
                printException(getCallerName(), getFunctionName(), err_msg,
                               e.args)
            n = 0
        finally:
            self.lock.release()

        return n
Beispiel #30
0
    def isBlockchainSynced(self):
        try:
            self.lock.acquire()
            res = self.conn.mnsync('status').get("IsBlockchainSynced")
        except Exception as e:
            if str(e.args[0]) != "Request-sent":
                err_msg = "error in isBlockchainSynced"
                printException(getCallerName(), getFunctionName(), err_msg,
                               e.args)
            res = False
        finally:
            self.lock.release()

        return res