示例#1
0
    def on_select_send_value(self, event):
        base58addrstr = self.wallet_view.send_view.address()
        amount_str = self.wallet_view.send_view.amount()
        if not BitcoinAddress.is_valid(base58addrstr,
                                       self.account.wallet.runmode):
            self.messages_view.error("Incorrect bitcoin address: %s" %
                                     (base58addrstr))
            return
        if not is_float(amount_str):
            self.messages_view.error("Incorrect amount: %s" % (amount_str))
            return
        planned_tx = self.account.create_transaction(
            int(float(amount_str) * COIN),
            BitcoinAddress.from_base58addr(base58addrstr), 0)
        self.wallet_view.send_view.close()

        passphrases = []
        try:
            if self.account.is_passphrase_required(planned_tx):
                passphrase = yield self.wallet_view.enter_passphrase_view.get_passphrase(
                )
                passphrases.append(passphrase)
            self.account.send_transaction(planned_tx, passphrases)
        except KeyDecryptException as e:
            self.messages_view.error(
                "Unable to decrypt the private keys: please verify the passphrase and try again."
            )
        except ActionCancelledException:
            pass
        except Exception as e:
            traceback.print_exc()
            self.messages_view.error("Error while sending transaction: %s" %
                                     (str(e)))
示例#2
0
 def test_address_from_base58addr(self):
     #TESTNET
     addr1 = BitcoinAddress.from_base58addr(
         "n4MsBRWD7VxKGsqYRSLaFZC6hQrsrKLaZo")
     self.assertEquals(hexstr(addr1.get_hash160()),
                       'fa92e151722c0ebca07059a505252218b4c50e7a')
     self.assertEquals(addr1.get_addr_version(),
                       AddressVersion(PUBKEY_ADDRESS_TEST))
     #TESTNET script address
     addr2 = BitcoinAddress.from_base58addr(
         "2NG68seqhTqLnniguW6efUDKyCHm4LYEFRa")
     self.assertEquals(hexstr(addr2.get_hash160()),
                       'fa92e151722c0ebca07059a505252218b4c50e7a')
     self.assertEquals(addr2.get_addr_version(),
                       AddressVersion(SCRIPT_ADDRESS_TEST))
     #MAIN
     addr2 = BitcoinAddress.from_base58addr(
         "1PqutNREJUX4VmMvhsNCRdymqRGAzifdsx")
     self.assertEquals(hexstr(addr2.get_hash160()),
                       'fa92e151722c0ebca07059a505252218b4c50e7a')
     self.assertEquals(addr2.get_addr_version(),
                       AddressVersion(PUBKEY_ADDRESS_MAIN))
     #MAIN Script address
     addr2 = BitcoinAddress.from_base58addr(
         "3QXvouufrNqSaw4Mpy2nrGLhywYtXx6wsi")
     self.assertEquals(hexstr(addr2.get_hash160()),
                       'fa92e151722c0ebca07059a505252218b4c50e7a')
     self.assertEquals(addr2.get_addr_version(),
                       AddressVersion(SCRIPT_ADDRESS_MAIN))
示例#3
0
 def load(self):
     for public_key, keypair in self.wallet_database.get_keys().iteritems():
         self.addresses[BitcoinAddress.from_publickey(
             public_key, self.runmode)] = (public_key, False)
     for public_key, secret in self.wallet_database.get_crypted_keys(
     ).iteritems():
         self.addresses[BitcoinAddress.from_publickey(
             public_key, self.runmode)] = (public_key, True)
示例#4
0
 def test_address_from_bytestring(self):
     addr1 = BitcoinAddress.from_bytestring(
         decodehexstr("0041fe507633463c246ec91502c2d67e8b3d81618e"))
     self.assertEquals(addr1.to_base58addr(),
                       "171waY81rzeFaBYhsiKibhBW5WAG8X7DLk")
     with self.assertRaises(InvalidBitcoinAddress):
         # not 21 characters
         addr2 = BitcoinAddress.from_bytestring(
             decodehexstr("0041fe507633463c246ec91502c2d67e8b3d81618e61"))
示例#5
0
 def test_address_is_valid(self):
     assert BitcoinAddress.is_valid("2NG68seqhTqLnniguW6efUDKyCHm4LYEFRa", TESTNET) #script addr
     assert BitcoinAddress.is_valid("n4MsBRWD7VxKGsqYRSLaFZC6hQrsrKLaZo", TESTNET) 
     assert BitcoinAddress.is_valid("112z9tWej11X94khKKzofFgWbdhiXLeHPD", MAIN)    
     assert BitcoinAddress.is_valid("3QXvouufrNqSaw4Mpy2nrGLhywYtXx6wsi", MAIN) #script addr 
     #checksum error
     assert not BitcoinAddress.is_valid("n4NsBRWD7VxKGsqYRSLaFZC6hQrsrKLaZo", TESTNET) 
     #invalid base64char l
     assert not BitcoinAddress.is_valid("n4lsBRWD7VxKGsqYRSLaFZC6hQrsrKLaZo", TESTNET) 
     # special case for MAIN, starting with multiple 1s 
     assert BitcoinAddress.is_valid("112z9tWej11X94khKKzofFgWbdhiXLeHPD", MAIN)    
     assert BitcoinAddress.is_valid("1111MJe7b4ZnktoPZabb6DLAKfac8tvx", MAIN)
     assert not BitcoinAddress.is_valid("11111MJe7b4ZnktoPZabb6DLAKfac8tvx", MAIN)
     assert not BitcoinAddress.is_valid("111MJe7b4ZnktoPZabb6DLAKfac8tvx", MAIN)
示例#6
0
 def test_address_from_public_key(self):
     """
     public: 023053536687205cbf57a25386ac466c7f85105032ced1ae9c54486a83c6dd3bab
     private: 049db42589b263e8700eb747a402b74604aae54ebc04f1cbe9a1cf584683f100
     """
     addr1 = BitcoinAddress.from_publickey(decodehexstr("023053536687205cbf57a25386ac466c7f85105032ced1ae9c54486a83c6dd3bab"), MAIN)
     self.assertEquals(addr1.to_base58addr(), "171waY81rzeFaBYhsiKibhBW5WAG8X7DLk")
示例#7
0
 def _read_names(self):
     for key, key_cursor, value, value_cursor in self._read_entries("name"):
         address_bytestr, _ = self.varstr_serializer.deserialize(
             key, key_cursor)
         name, _ = self.varstr_serializer.deserialize(value, value_cursor)
         address = BitcoinAddress.from_base58addr(address_bytestr)
         self.names[address] = WalletName(name, address)
示例#8
0
 def test_address_from_base58addr(self):
     #TESTNET 
     addr1 = BitcoinAddress.from_base58addr("n4MsBRWD7VxKGsqYRSLaFZC6hQrsrKLaZo")
     self.assertEquals(hexstr(addr1.get_hash160()), 'fa92e151722c0ebca07059a505252218b4c50e7a')
     self.assertEquals(addr1.get_addr_version(), AddressVersion(PUBKEY_ADDRESS_TEST))
     #TESTNET script address
     addr2 = BitcoinAddress.from_base58addr("2NG68seqhTqLnniguW6efUDKyCHm4LYEFRa")
     self.assertEquals(hexstr(addr2.get_hash160()), 'fa92e151722c0ebca07059a505252218b4c50e7a')
     self.assertEquals(addr2.get_addr_version(), AddressVersion(SCRIPT_ADDRESS_TEST))
     #MAIN
     addr2 = BitcoinAddress.from_base58addr("1PqutNREJUX4VmMvhsNCRdymqRGAzifdsx")
     self.assertEquals(hexstr(addr2.get_hash160()), 'fa92e151722c0ebca07059a505252218b4c50e7a')
     self.assertEquals(addr2.get_addr_version(), AddressVersion(PUBKEY_ADDRESS_MAIN))
     #MAIN Script address
     addr2 = BitcoinAddress.from_base58addr("3QXvouufrNqSaw4Mpy2nrGLhywYtXx6wsi")
     self.assertEquals(hexstr(addr2.get_hash160()), 'fa92e151722c0ebca07059a505252218b4c50e7a')
     self.assertEquals(addr2.get_addr_version(), AddressVersion(SCRIPT_ADDRESS_MAIN))
示例#9
0
    def set_receive_label(self, address_base58, label):
        address = BitcoinAddress.from_base58addr(address_base58)
        self.wallet.begin_updates()
        public_key, is_crypted = self.wallet.addresses[address]  # decode_base58check(address)[1:]
        self.wallet.allocate_key(public_key, label)
        self.wallet.commit_updates()

        new_description = self.wallet.get_address_description(public_key)
        self.fire(self.EVT_NEW_ADDRESS_DESCRIPTION, public_key=public_key, description=new_description)
示例#10
0
 def test_address_from_public_key(self):
     """
     public: 023053536687205cbf57a25386ac466c7f85105032ced1ae9c54486a83c6dd3bab
     private: 049db42589b263e8700eb747a402b74604aae54ebc04f1cbe9a1cf584683f100
     """
     addr1 = BitcoinAddress.from_publickey(
         decodehexstr(
             "023053536687205cbf57a25386ac466c7f85105032ced1ae9c54486a83c6dd3bab"
         ), MAIN)
     self.assertEquals(addr1.to_base58addr(),
                       "171waY81rzeFaBYhsiKibhBW5WAG8X7DLk")
示例#11
0
    def set_receive_label(self, address_base58, label):
        address = BitcoinAddress.from_base58addr(address_base58)
        self.wallet.begin_updates()
        public_key, is_crypted = self.wallet.addresses[
            address]  #decode_base58check(address)[1:]
        self.wallet.allocate_key(public_key, label)
        self.wallet.commit_updates()

        new_description = self.wallet.get_address_description(public_key)
        self.fire(self.EVT_NEW_ADDRESS_DESCRIPTION,
                  public_key=public_key,
                  description=new_description)
示例#12
0
文件: wallet.py 项目: sirk390/coinpy
 def get_address_description(self, public_key):
     address = BitcoinAddress.from_publickey(public_key, self.runmode)
     description = ""
     if public_key in self.wallet_database.poolkeys_by_public_key:
         poolkey = self.wallet_database.poolkeys_by_public_key[public_key]
         description = "Pool (id:%d, time:%s)" % (poolkey.poolnum, time.strftime("%Y-%m-%d %H:%m:%S", time.gmtime(poolkey.time)))
     else:
         if address in self.wallet_database.get_names():
             description = "Receive (\"%s\")" % self.wallet_database.get_names()[address].name
         else: 
             description = "Change" 
     return description
示例#13
0
    def create_transaction(self, amount, address, fee):
        outputs = [(outpoint, txout) for (tx, outpoint, txout) in self.iter_my_outputs()]
        selected_outputs = self.coin_selector.select_coins(outputs, (amount + fee))

        change_public_key = self.wallet.get_receive_key()
        change_address = BitcoinAddress.from_publickey(change_public_key, self.wallet.runmode)
        tx = create_pubkeyhash_transaction(
            selected_outputs,
            address.get_hash160(),  # decode_base58check(address)[1:],  #remove ADDRESSVERSION[runmode] byte
            change_address.get_hash160(),  # decode_base58check(change_address)[1:],  #remove ADDRESSVERSION[runmode] byte
            amount,
            fee,
        )
        return PlannedTransaction(selected_outputs, amount, address, change_public_key, change_address, fee, tx)
示例#14
0
 def test_address_is_valid(self):
     assert BitcoinAddress.is_valid("2NG68seqhTqLnniguW6efUDKyCHm4LYEFRa",
                                    TESTNET)  #script addr
     assert BitcoinAddress.is_valid("n4MsBRWD7VxKGsqYRSLaFZC6hQrsrKLaZo",
                                    TESTNET)
     assert BitcoinAddress.is_valid("112z9tWej11X94khKKzofFgWbdhiXLeHPD",
                                    MAIN)
     assert BitcoinAddress.is_valid("3QXvouufrNqSaw4Mpy2nrGLhywYtXx6wsi",
                                    MAIN)  #script addr
     #checksum error
     assert not BitcoinAddress.is_valid(
         "n4NsBRWD7VxKGsqYRSLaFZC6hQrsrKLaZo", TESTNET)
     #invalid base64char l
     assert not BitcoinAddress.is_valid(
         "n4lsBRWD7VxKGsqYRSLaFZC6hQrsrKLaZo", TESTNET)
     # special case for MAIN, starting with multiple 1s
     assert BitcoinAddress.is_valid("112z9tWej11X94khKKzofFgWbdhiXLeHPD",
                                    MAIN)
     assert BitcoinAddress.is_valid("1111MJe7b4ZnktoPZabb6DLAKfac8tvx",
                                    MAIN)
     assert not BitcoinAddress.is_valid("11111MJe7b4ZnktoPZabb6DLAKfac8tvx",
                                        MAIN)
     assert not BitcoinAddress.is_valid("111MJe7b4ZnktoPZabb6DLAKfac8tvx",
                                        MAIN)
示例#15
0
 def get_address_description(self, public_key):
     address = BitcoinAddress.from_publickey(public_key, self.runmode)
     description = ""
     if public_key in self.wallet_database.poolkeys_by_public_key:
         poolkey = self.wallet_database.poolkeys_by_public_key[public_key]
         description = "Pool (id:%d, time:%s)" % (
             poolkey.poolnum,
             time.strftime("%Y-%m-%d %H:%m:%S", time.gmtime(poolkey.time)))
     else:
         if address in self.wallet_database.get_names():
             description = "Receive (\"%s\")" % self.wallet_database.get_names(
             )[address].name
         else:
             description = "Change"
     return description
    def test_shamir_share_private_key(self):
        ssl_add_system_seeds()
        k = KEY()
        k.generate()
        pkey_bignum = k.get_privkey_bignum()
        pubkey = k.get_pubkey()
        numshares = 600
        threshold = 100
        sharenum_bytes = 2
        print "private_key_bignum:", pkey_bignum
        print "public_key:", hexstr(pubkey)
        print "address:", BitcoinAddress.from_publickey(pubkey, MAIN)
        
        field = ZpField()
        V = field.value_type
        ZpPkey = V(pkey_bignum)

        sharer = SecretSharer(field, ZpRandom(field))
        shares = sharer.share(ZpPkey, threshold, [V(i+1) for i in range(numshares)])
        # print shares
        print "Shamir Shares: (%d/%d):" % (threshold, numshares)
        shares_hex = [hexstr(base256encode(int(pt), sharenum_bytes) + base256encode(int(value), 32)) for pt, value in shares]
        
        for share in shares_hex:
            print share
        # Try to reconstruct the private key using the hex encoded shares.
        recombiner = SecretRecombiner(field)
        for i in range(10):
            random4_hex = random.sample(shares_hex, threshold)
            random4_decoded = [decodehexstr(h) for h in random4_hex]
            random4 = [(V(base256decode(data[:sharenum_bytes])), V(base256decode(data[sharenum_bytes:]))) for data in random4_decoded]
            recombined_pkey_bignum = recombiner.recombine(random4, V(0))
            assert recombined_pkey_bignum == ZpPkey
            k2 = KEY()
            k2.set_privkey_bignum(int(recombined_pkey_bignum))
            assert k2.get_pubkey() == pubkey
            print i
        # With threshold-1 shares this fails
        for i in range(10):
            random4_hex = random.sample(shares_hex, threshold-1)
            random4_decoded = [decodehexstr(h) for h in random4_hex]
            random4 = [(V(base256decode(data[:sharenum_bytes])), V(base256decode(data[sharenum_bytes:]))) for data in random4_decoded]
            recombined_pkey_bignum = recombiner.recombine(random4, V(0))
            assert recombined_pkey_bignum != ZpPkey
示例#17
0
    def create_transaction(self, amount, address, fee):
        outputs = [(outpoint, txout)
                   for (tx, outpoint, txout) in self.iter_my_outputs()]
        selected_outputs = self.coin_selector.select_coins(
            outputs, (amount + fee))

        change_public_key = self.wallet.get_receive_key()
        change_address = BitcoinAddress.from_publickey(change_public_key,
                                                       self.wallet.runmode)
        tx = create_pubkeyhash_transaction(
            selected_outputs,
            address.get_hash160(
            ),  #decode_base58check(address)[1:],  #remove ADDRESSVERSION[runmode] byte
            change_address.get_hash160(
            ),  #decode_base58check(change_address)[1:],  #remove ADDRESSVERSION[runmode] byte
            amount,
            fee)
        return (PlannedTransaction(selected_outputs, amount, address,
                                   change_public_key, change_address, fee, tx))
示例#18
0
 def test_address_get_addr_version(self):
     self.assertEquals(
         BitcoinAddress(
             decodehexstr("b0600c55b16851c4f9d0e2c82fa161ac8190e04c"),
             AddressVersion(PUBKEY_ADDRESS_TEST)).get_addr_version(),
         AddressVersion(PUBKEY_ADDRESS_TEST))
示例#19
0
文件: wallet.py 项目: sirk390/coinpy
 def allocate_key(self, public_key, label=None, ischange=False):
     address = BitcoinAddress.from_publickey(public_key, self.runmode) 
     return self.wallet_database.allocate_key(public_key, address, label)
示例#20
0
 def get_receive_address(self):
     public_key = self.wallet.get_receive_key()
     return BitcoinAddress.from_publickey(public_key, self.wallet.runmode)
示例#21
0
 def test_address_from_bytestring(self):
     addr1 = BitcoinAddress.from_bytestring(decodehexstr("0041fe507633463c246ec91502c2d67e8b3d81618e"))
     self.assertEquals(addr1.to_base58addr(), "171waY81rzeFaBYhsiKibhBW5WAG8X7DLk")
     with self.assertRaises(InvalidBitcoinAddress):
         # not 21 characters
         addr2 = BitcoinAddress.from_bytestring(decodehexstr("0041fe507633463c246ec91502c2d67e8b3d81618e61"))
示例#22
0
 def _read_names(self):
     for key, key_cursor, value, value_cursor in self._read_entries("name"):
         address_bytestr, _ = self.varstr_serializer.deserialize(key, key_cursor)
         name, _ = self.varstr_serializer.deserialize(value, value_cursor)
         address = BitcoinAddress.from_base58addr(address_bytestr)
         self.names[address] = WalletName(name, address)
示例#23
0
 def test_address_to_base58addr(self):
     self.assertEquals(
         BitcoinAddress(
             decodehexstr("b0600c55b16851c4f9d0e2c82fa161ac8190e04c"),
             AddressVersion(PUBKEY_ADDRESS_MAIN)).to_base58addr(),
         "1H5azJoKoYd92DxjXX7k7gejpbLVMAczAi")
示例#24
0
 def test_address_to_hexstring(self):
     self.assertEquals(
         BitcoinAddress(
             decodehexstr("b0600c55b16851c4f9d0e2c82fa161ac8190e04c"),
             AddressVersion(PUBKEY_ADDRESS_MAIN)).to_hexstring(),
         "00b0600c55b16851c4f9d0e2c82fa161ac8190e04c")
示例#25
0
文件: wallet.py 项目: sirk390/coinpy
 def load(self):
     for public_key, keypair in self.wallet_database.get_keys().iteritems():
         self.addresses[BitcoinAddress.from_publickey(public_key, self.runmode)] = (public_key, False)
     for public_key, secret in self.wallet_database.get_crypted_keys().iteritems():
         self.addresses[BitcoinAddress.from_publickey(public_key, self.runmode)] = (public_key, True)
示例#26
0
 def allocate_key(self, public_key, label=None, ischange=False):
     address = BitcoinAddress.from_publickey(public_key, self.runmode)
     return self.wallet_database.allocate_key(public_key, address, label)
示例#27
0
 def get_receive_address(self):
     public_key = self.wallet.get_receive_key()
     return BitcoinAddress.from_publickey(public_key, self.wallet.runmode)