def testDumpprivkey(self):

      testPrivKey = self.privKey.toBinStr()
      hash160 = convertKeyDataToAddress(testPrivKey)
      addr58 = hash160_to_addrStr(hash160)
      
      # Verify that a bogus addrss Raises InvalidBitcoinAddress Exception
      self.assertRaises(InvalidBitcoinAddress, self.jsonServer.jsonrpc_dumpprivkey, 'bogus')
      
      # verify that the root private key is not found
      self.assertRaises(PrivateKeyNotFound, self.jsonServer.jsonrpc_dumpprivkey, addr58)
      
      # verify that the first private key can be found
      firstHash160 = self.wallet.getNextUnusedAddress().getAddr160()
      firstAddr58 = hash160_to_addrStr(firstHash160)
      actualPrivateKey = self.jsonServer.jsonrpc_dumpprivkey(firstAddr58)
      expectedPrivateKey = self.wallet.getAddrByHash160(firstHash160).serializePlainPrivateKey()
      self.assertEqual(actualPrivateKey, expectedPrivateKey)
      
      # Verify that a locked wallet Raises WalletUnlockNeeded Exception
      kdfParams = self.wallet.computeSystemSpecificKdfParams(0.1)
      self.wallet.changeKdfParams(*kdfParams)
      self.wallet.changeWalletEncryption( securePassphrase=self.passphrase )
      self.wallet.lock()
      self.assertRaises(WalletUnlockNeeded, self.jsonServer.jsonrpc_dumpprivkey, addr58)
   def testDumpprivkey(self):
      testPrivKey = self.privKey.toBinStr()
      hash160 = convertKeyDataToAddress(testPrivKey)
      addr58 = hash160_to_addrStr(hash160)
      
      # Verify that a bogus addrss Raises InvalidBitcoinAddress Exception
      result =  self.jsonServer.jsonrpc_dumpprivkey('bogus', 'hex')
      self.assertEqual(result['Error Type'],'InvalidBitcoinAddress')

      result =  self.jsonServer.jsonrpc_dumpprivkey(addr58, 'hex')
      self.assertEqual(result['Error Type'],'PrivateKeyNotFound')

      # verify that the first private key can be found
      firstHash160 = self.wallet.getNextUnusedAddress().getAddr160()
      firstAddr58 = hash160_to_addrStr(firstHash160)
      actualPrivateKeyHex = self.jsonServer.jsonrpc_dumpprivkey(firstAddr58, \
                                                                'hex')
      actualPrivateKeyB58 = self.jsonServer.jsonrpc_dumpprivkey(firstAddr58, \
                                                                'base58')
      self.privKey = self.wallet.getAddrByHash160(firstHash160).serializePlainPrivateKey()
      expectedPrivateKeyHex = binary_to_hex(self.privKey)
      expectedPrivateKeyB58 = privKey_to_base58(self.privKey)
      self.assertEqual(actualPrivateKeyHex, expectedPrivateKeyHex)
      self.assertEqual(actualPrivateKeyB58, expectedPrivateKeyB58)

      # Verify that a locked wallet Raises WalletUnlockNeeded Exception
      kdfParams = self.wallet.computeSystemSpecificKdfParams(0.1)
      self.wallet.changeKdfParams(*kdfParams)
      self.wallet.changeWalletEncryption( securePassphrase=self.passphrase )
      self.wallet.lock()
      result = self.jsonServer.jsonrpc_dumpprivkey(addr58, 'hex')
      self.assertEqual(result['Error Type'],'WalletUnlockNeeded')
Example #3
0
    def testDumpprivkey(self):
        testPrivKey = self.privKey.toBinStr()
        hash160 = convertKeyDataToAddress(testPrivKey)
        addr58 = hash160_to_addrStr(hash160)

        # Verify that a bogus addrss Raises InvalidBitcoinAddress Exception
        result = self.jsonServer.jsonrpc_dumpprivkey('bogus', 'hex')
        self.assertEqual(result['Error Type'], 'InvalidBitcoinAddress')

        result = self.jsonServer.jsonrpc_dumpprivkey(addr58, 'hex')
        self.assertEqual(result['Error Type'], 'PrivateKeyNotFound')

        # verify that the first private key can be found
        firstHash160 = self.wallet.getNextUnusedAddress().getAddr160()
        firstAddr58 = hash160_to_addrStr(firstHash160)
        actualPrivateKeyHex = self.jsonServer.jsonrpc_dumpprivkey(firstAddr58, \
                                                                  'hex')
        actualPrivateKeyB58 = self.jsonServer.jsonrpc_dumpprivkey(firstAddr58, \
                                                                  'base58')
        self.privKey = self.wallet.getAddrByHash160(
            firstHash160).serializePlainPrivateKey()
        expectedPrivateKeyHex = binary_to_hex(self.privKey)
        expectedPrivateKeyB58 = privKey_to_base58(self.privKey)
        self.assertEqual(actualPrivateKeyHex, expectedPrivateKeyHex)
        self.assertEqual(actualPrivateKeyB58, expectedPrivateKeyB58)

        # Verify that a locked wallet Raises WalletUnlockNeeded Exception
        kdfParams = self.wallet.computeSystemSpecificKdfParams(0.1)
        self.wallet.changeKdfParams(*kdfParams)
        self.wallet.changeWalletEncryption(securePassphrase=self.passphrase)
        self.wallet.lock()
        result = self.jsonServer.jsonrpc_dumpprivkey(addr58, 'hex')
        self.assertEqual(result['Error Type'], 'WalletUnlockNeeded')
    def testDumpprivkey(self):

        testPrivKey = self.privKey.toBinStr()
        hash160 = convertKeyDataToAddress(testPrivKey)
        addr58 = hash160_to_addrStr(hash160)

        # Verify that a bogus addrss Raises InvalidBitcoinAddress Exception
        self.assertRaises(InvalidBitcoinAddress,
                          self.jsonServer.jsonrpc_dumpprivkey, 'bogus')

        # verify that the root private key is not found
        self.assertRaises(PrivateKeyNotFound,
                          self.jsonServer.jsonrpc_dumpprivkey, addr58)

        # verify that the first private key can be found
        firstHash160 = self.wallet.getNextUnusedAddress().getAddr160()
        firstAddr58 = hash160_to_addrStr(firstHash160)
        actualPrivateKey = self.jsonServer.jsonrpc_dumpprivkey(firstAddr58)
        expectedPrivateKey = self.wallet.getAddrByHash160(
            firstHash160).serializePlainPrivateKey()
        self.assertEqual(actualPrivateKey, expectedPrivateKey)

        # Verify that a locked wallet Raises WalletUnlockNeeded Exception
        kdfParams = self.wallet.computeSystemSpecificKdfParams(0.1)
        self.wallet.changeKdfParams(*kdfParams)
        self.wallet.changeWalletEncryption(securePassphrase=self.passphrase)
        self.wallet.lock()
        self.assertRaises(WalletUnlockNeeded,
                          self.jsonServer.jsonrpc_dumpprivkey, addr58)
def pprintUnspentTxOutList(utxoList, headerLine='Coin Selection: '):
   totalSum = sum([u.getValue() for u in utxoList])
   print headerLine, '(Total = %s BTC)' % coin2str(totalSum)
   print '   ','Owner Address'.ljust(34),
   print '   ','TxOutValue'.rjust(18),
   print '   ','NumConf'.rjust(8),
   print '   ','PriorityFactor'.rjust(16)
   for utxo in utxoList:
      a160 = CheckHash160(utxo.getRecipientScrAddr())
      print '   ',hash160_to_addrStr(a160).ljust(34),
      print '   ',(coin2str(utxo.getValue()) + ' BTC').rjust(18),
      print '   ',str(utxo.getNumConfirm()).rjust(8),
      print '   ', ('%0.2f' % (utxo.getValue()*utxo.getNumConfirm()/(ONE_BTC*144.))).rjust(16)
   def testSimpleAddress(self):
      # Execute the tests with Satoshi's public key from the Bitcoin specification page
      satoshiPubKeyHex = '04fc9702847840aaf195de8442ebecedf5b095cdbb9bc716bda9110971b28a49e0ead8564ff0db22209e0374782c093bb899692d524e9d6a6956e7c5ecbcd68284'
      addrPiece1Hex = '65a4358f4691660849d9f235eb05f11fabbd69fa'
      addrPiece1Bin = hex_to_binary(addrPiece1Hex)
      satoshiAddrStr = hash160_to_addrStr(addrPiece1Bin)

      saddr = PyBtcAddress().createFromPublicKey( hex_to_binary(satoshiPubKeyHex) )
      print '\tAddr calc from pubkey: ', saddr.calculateAddrStr()
      self.assertTrue(checkAddrStrValid(satoshiAddrStr))
   
      testAddr = PyBtcAddress().createFromPlainKeyData(PRIVATE_KEY, ADDRESS_20, publicKey65=PUBLIC_KEY)
      msg = int_to_binary(39029348428)
      theHash = hash256(msg)
      derSig = testAddr.generateDERSignature(theHash)
      # Testing ECDSA signing & verification -- arbitrary binary strings:
      self.assertTrue(testAddr.verifyDERSignature( theHash, derSig))
    def testSimpleAddress(self):
        # Execute the tests with Satoshi's public key from the Bitcoin specification page
        satoshiPubKeyHex = '04fc9702847840aaf195de8442ebecedf5b095cdbb9bc716bda9110971b28a49e0ead8564ff0db22209e0374782c093bb899692d524e9d6a6956e7c5ecbcd68284'
        addrPiece1Hex = '65a4358f4691660849d9f235eb05f11fabbd69fa'
        addrPiece1Bin = hex_to_binary(addrPiece1Hex)
        satoshiAddrStr = hash160_to_addrStr(addrPiece1Bin)

        saddr = PyBtcAddress().createFromPublicKey(
            hex_to_binary(satoshiPubKeyHex))
        print '\tAddr calc from pubkey: ', saddr.calculateAddrStr()
        self.assertTrue(checkAddrStrValid(satoshiAddrStr))

        testAddr = PyBtcAddress().createFromPlainKeyData(
            PRIVATE_KEY, ADDRESS_20, publicKey65=PUBLIC_KEY)
        msg = int_to_binary(39029348428)
        theHash = hash256(msg)
        derSig = testAddr.generateDERSignature(theHash)
        # Testing ECDSA signing & verification -- arbitrary binary strings:
        self.assertTrue(testAddr.verifyDERSignature(theHash, derSig))
Example #8
0
    def __init__(self, parent, utxo):
        self.utxo = utxo
        self.parent = parent
        if utxo.getTxHeight() == 2**32 - 1:
            self.name = QObject().tr("ZC id: %1 | TxOut: %2").arg(\
               unicode(utxo.getTxIndex()), \
               unicode(utxo.getTxOutIndex()))
        else:
            self.name = QObject().tr("Block: #%1 | Tx: #%2 | TxOut: #%3").arg(\
               unicode(utxo.getTxHeight()), \
               unicode(utxo.getTxIndex()), \
               unicode(utxo.getTxOutIndex()))

        self.state = Qt.Checked
        if utxo.isChecked() == False:
            self.state = Qt.Unchecked

        h160 = utxo.getRecipientHash160()
        binAddr = utxo.getRecipientScrAddr()
        self.scrAddr = hash160_to_addrStr(h160, binAddr[0])

        self.value = coin2str(utxo.getValue(), maxZeros=2)
Example #9
0
 def __init__(self, parent, utxo):
    self.utxo = utxo
    self.parent = parent
    if utxo.getTxHeight() == 2**32 - 1:
       self.name = QObject().tr("ZC id: %1 | TxOut: %2").arg(\
          unicode(utxo.getTxIndex()), \
          unicode(utxo.getTxOutIndex()))
    else:
       self.name = QObject().tr("Block: #%1 | Tx: #%2 | TxOut: #%3").arg(\
          unicode(utxo.getTxHeight()), \
          unicode(utxo.getTxIndex()), \
          unicode(utxo.getTxOutIndex()))
    
    self.state = Qt.Checked
    if utxo.isChecked() == False:
       self.state = Qt.Unchecked
       
    h160 = utxo.getRecipientHash160()
    binAddr = utxo.getRecipientScrAddr()
    self.scrAddr = hash160_to_addrStr(h160, binAddr[0])   
    
    self.value = coin2str(utxo.getValue(), maxZeros=2)      
 def testGetreceivedbyaddress(self):
    a160 = hash160(self.wallet.getNextUnusedAddress().binPublicKey65.toBinStr())
    testAddr = hash160_to_addrStr(a160)
    result = self.jsonServer.jsonrpc_getreceivedbyaddress(testAddr)
    self.assertEqual(result, 0)
Example #11
0
 def testGetreceivedbyaddress(self):
     a160 = hash160(
         self.wallet.getNextUnusedAddress().binPublicKey65.toBinStr())
     testAddr = hash160_to_addrStr(a160)
     result = self.jsonServer.jsonrpc_getreceivedbyaddress(testAddr)
     self.assertEqual(result, 0)
Example #12
0
    def setup(self):
        self.treeData = {
            'UTXO': {
                'p2pkh': dict(),
                'p2sh_p2pk': dict(),
                'p2sh_p2wpkh': dict()
            },
            'RBF': dict(),
            'CPFP': dict()
        }

        #populate utxos
        utxoList = self.wallet.getFullUTXOList()

        #arrange by script type
        for utxo in utxoList:
            h160 = utxo.getRecipientHash160()
            binAddr = utxo.getRecipientScrAddr()
            scrAddr = hash160_to_addrStr(h160, binAddr[0])

            assetId = self.wallet.cppWallet.getAssetIndexForAddr(h160)
            addrType = self.wallet.cppWallet.getAddrTypeForIndex_WithScript(
                assetId, h160)

            addrDict = None
            if addrType == AddressType_P2PKH:
                addrDict = self.treeData['UTXO']['p2pkh']
            elif addrType == AddressType_P2SH_P2PK:
                addrDict = self.treeData['UTXO']['p2sh_p2pk']
            elif addrType == AddressType_P2SH_P2WPKH:
                addrDict = self.treeData['UTXO']['p2sh_p2wpkh']

            if addrDict == None:
                continue

            if not scrAddr in addrDict:
                addrDict[scrAddr] = []

            addrDict[scrAddr].append(utxo)

        #populate cpfp
        cpfpList = self.wallet.getZCUTXOList()
        addrDict = self.treeData['CPFP']
        for cpfp in cpfpList:
            h160 = cpfp.getRecipientHash160()
            binAddr = cpfp.getRecipientScrAddr()
            scrAddr = hash160_to_addrStr(h160, binAddr[0])

            if not scrAddr in addrDict:
                addrDict[scrAddr] = []

            addrDict[scrAddr].append(cpfp)

        #create root node
        self.root = CoinControlTreeNode(self, "root", True, None)

        def createUtxoNode(name):
            nodeMain = CoinControlTreeNode(self, name, True, None)

            def ccFilterP2PKH():
                return self.treeData['UTXO']['p2pkh']

            def ccFilterP2SH_P2PK():
                return self.treeData['UTXO']['p2sh_p2pk']

            def ccFilterP2SH_P2WPKH():
                return self.treeData['UTXO']['p2sh_p2wpkh']

            nodeP2KH = CoinControlTreeNode(nodeMain, "P2PKH", True,
                                           ccFilterP2PKH)
            nodeMain.appendEntry(nodeP2KH)

            nodeP2SH_P2PK = CoinControlTreeNode(nodeMain, "P2SH-P2PK", True,
                                                ccFilterP2SH_P2PK)
            nodeMain.appendEntry(nodeP2SH_P2PK)

            nodeP2SH_P2WPKH = CoinControlTreeNode(nodeMain, "P2SH-P2WPKH",
                                                  True, ccFilterP2SH_P2WPKH)
            nodeMain.appendEntry(nodeP2SH_P2WPKH)

            return nodeMain

        def createCPFPNode(name):
            def ccCPFP():
                return self.treeData['CPFP']

            nodeMain = CoinControlTreeNode(None, name, True, ccCPFP)

            return nodeMain

        #create top 3 nodes
        nodeUTXO = createUtxoNode(QObject().tr("Unspent Outputs"))
        #nodeRBF = createChildNode(self.main.tr("RBF Eligible"), "RBF")
        nodeCPFP = createCPFPNode(QObject().tr("CPFP Eligible Outputs"))

        self.root.appendEntry(nodeUTXO)
        #self.root.appendEntry(nodeRBF)
        self.root.appendEntry(nodeCPFP)
        nodeCPFP.setCheckState(Qt.Unchecked)
        self.root.checkStatus = self.root.computeState()
Example #13
0
 def setup(self):
    self.treeData = {
       'UTXO':{
          'p2pkh':dict(),
          'p2sh_p2pk':dict(),
          'p2sh_p2wpkh':dict()},
       'RBF':dict(),
       'CPFP':dict()
       }
    
    #populate utxos
    utxoList = self.wallet.getFullUTXOList()     
           
    #arrange by script type
    for utxo in utxoList:
       h160 = utxo.getRecipientHash160()
       binAddr = utxo.getRecipientScrAddr()
       scrAddr = hash160_to_addrStr(h160, binAddr[0])
          
       assetId = self.wallet.cppWallet.getAssetIndexForAddr(h160)
       addrType = self.wallet.cppWallet.getAddrTypeForIndex(assetId) 
               
       addrDict = None
       if addrType == AddressType_P2PKH:
          addrDict = self.treeData['UTXO']['p2pkh']
       elif addrType == AddressType_P2SH_P2PK:
          addrDict = self.treeData['UTXO']['p2sh_p2pk']
       elif addrType == AddressType_P2SH_P2WPKH:
          addrDict = self.treeData['UTXO']['p2sh_p2wpkh']
          
       if addrDict == None:
          continue
       
       if not scrAddr in addrDict:
          addrDict[scrAddr] = []
          
       addrDict[scrAddr].append(utxo)
       
    #populate cpfp
    cpfpList = self.wallet.getZCUTXOList()
    addrDict = self.treeData['CPFP']
    for cpfp in cpfpList:
       h160 = cpfp.getRecipientHash160()
       binAddr = cpfp.getRecipientScrAddr()
       scrAddr = hash160_to_addrStr(h160, binAddr[0]) 
       
       if not scrAddr in addrDict:
          addrDict[scrAddr] = []
          
       addrDict[scrAddr].append(cpfp)           
              
    #create root node
    self.root = CoinControlTreeNode(self, "root", True, None)
    
    def createUtxoNode(name):
       nodeMain = CoinControlTreeNode(self, name, True, None)
       
       def ccFilterP2PKH():
          return self.treeData['UTXO']['p2pkh']
       
       def ccFilterP2SH_P2PK():
          return self.treeData['UTXO']['p2sh_p2pk']
       
       def ccFilterP2SH_P2WPKH():
          return self.treeData['UTXO']['p2sh_p2wpkh']
    
       
       nodeP2KH = CoinControlTreeNode(nodeMain, "P2PKH", True, ccFilterP2PKH)
       nodeMain.appendEntry(nodeP2KH)
       
       nodeP2SH_P2PK = CoinControlTreeNode(nodeMain, "P2SH-P2PK", True, ccFilterP2SH_P2PK)
       nodeMain.appendEntry(nodeP2SH_P2PK)
       
       nodeP2SH_P2WPKH = CoinControlTreeNode(nodeMain, "P2SH-P2WPKH", True, ccFilterP2SH_P2WPKH)
       nodeMain.appendEntry(nodeP2SH_P2WPKH)
       
       return nodeMain
    
    def createCPFPNode(name):
       def ccCPFP():
          return self.treeData['CPFP']
       
       nodeMain = CoinControlTreeNode(None, name, True, ccCPFP) 
       
       return nodeMain
    
    #create top 3 nodes
    nodeUTXO   = createUtxoNode(QObject().tr("Unspent Outputs"))
    #nodeRBF = createChildNode(self.main.tr("RBF Eligible"), "RBF")
    nodeCPFP = createCPFPNode(QObject().tr("CPFP Eligible Outputs"))
    
    self.root.appendEntry(nodeUTXO)
    #self.root.appendEntry(nodeRBF)
    self.root.appendEntry(nodeCPFP)
    nodeCPFP.setCheckState(Qt.Unchecked)
    self.root.checkStatus = self.root.computeState()