def do_test(exp_hex, wif, c_wif, public_pair_sec, c_public_pair_sec, address_b58, c_address_b58): secret_exponent = int(exp_hex, 16) sec = binascii.unhexlify(public_pair_sec) c_sec = binascii.unhexlify(c_public_pair_sec) self.assertEqual( secret_exponent_to_wif(secret_exponent, compressed=False), wif) self.assertEqual( secret_exponent_to_wif(secret_exponent, compressed=True), c_wif) exponent, compressed = wif_to_tuple_of_secret_exponent_compressed( wif) self.assertEqual(exponent, secret_exponent) self.assertFalse(compressed) exponent, compressed = wif_to_tuple_of_secret_exponent_compressed( c_wif) self.assertEqual(exponent, secret_exponent) self.assertTrue(compressed) public_pair = public_pair_for_secret_exponent( generator_secp256k1, secret_exponent) pk_public_pair = public_pair_from_sec(sec) compressed = is_sec_compressed(sec) self.assertEqual(pk_public_pair, public_pair) self.assertFalse(is_sec_compressed(sec)) self.assertEqual( public_pair_to_sec(pk_public_pair, compressed=False), sec) pk_public_pair = public_pair_from_sec(c_sec) compressed = is_sec_compressed(c_sec) self.assertEqual(pk_public_pair, public_pair) self.assertTrue(compressed) self.assertEqual( public_pair_to_sec(pk_public_pair, compressed=True), c_sec) bca = public_pair_to_bitcoin_address(pk_public_pair, compressed=True) self.assertEqual(bca, c_address_b58) self.assertEqual( bitcoin_address_to_ripemd160_sha_sec(c_address_b58), public_pair_to_ripemd160_sha_sec(pk_public_pair, compressed=True)) bca = public_pair_to_bitcoin_address(pk_public_pair, compressed=False) self.assertEqual(bca, address_b58) self.assertEqual( bitcoin_address_to_ripemd160_sha_sec(address_b58), public_pair_to_ripemd160_sha_sec(pk_public_pair, compressed=False))
def main(): parser = argparse.ArgumentParser(description="Bitcoin utilities. WARNING: obsolete. Use ku instead.") parser.add_argument('-a', "--address", help='show as Bitcoin address', action='store_true') parser.add_argument('-1', "--hash160", help='show as hash 160', action='store_true') parser.add_argument('-v', "--verbose", help='dump all information available', action='store_true') parser.add_argument('-w', "--wif", help='show as Bitcoin WIF', action='store_true') parser.add_argument('-n', "--uncompressed", help='show in uncompressed form', action='store_true') parser.add_argument('item', help='a WIF, secret exponent, X/Y public pair, SEC (as hex), hash160 (as hex), Bitcoin address', nargs="+") args = parser.parse_args() for c in args.item: # figure out what it is: # - secret exponent # - WIF # - X/Y public key (base 10 or hex) # - sec # - hash160 # - Bitcoin address secret_exponent = parse_as_private_key(c) if secret_exponent: public_pair = ecdsa.public_pair_for_secret_exponent(secp256k1.generator_secp256k1, secret_exponent) print("secret exponent: %d" % secret_exponent) print(" hex: %x" % secret_exponent) print("WIF: %s" % encoding.secret_exponent_to_wif(secret_exponent, compressed=True)) print(" uncompressed: %s" % encoding.secret_exponent_to_wif(secret_exponent, compressed=False)) else: public_pair = parse_as_public_pair(c) if public_pair: bitcoin_address_uncompressed = encoding.public_pair_to_bitcoin_address(public_pair, compressed=False) bitcoin_address_compressed = encoding.public_pair_to_bitcoin_address(public_pair, compressed=True) print("public pair x: %d" % public_pair[0]) print("public pair y: %d" % public_pair[1]) print(" x as hex: %x" % public_pair[0]) print(" y as hex: %x" % public_pair[1]) print("y parity: %s" % "odd" if (public_pair[1] & 1) else "even") print("key pair as sec: %s" % b2h(encoding.public_pair_to_sec(public_pair, compressed=True))) s = b2h(encoding.public_pair_to_sec(public_pair, compressed=False)) print(" uncompressed: %s\\\n %s" % (s[:66], s[66:])) hash160 = encoding.public_pair_to_hash160_sec(public_pair, compressed=True) hash160_unc = encoding.public_pair_to_hash160_sec(public_pair, compressed=False) myeccpoint = encoding.public_pair_to_sec(public_pair, compressed=True) myhash = encoding.ripemd160( myeccpoint ).digest( ) print("BTSX PubKey: %s" % BTS_ADDRESS_PREFIX + encoding.b2a_base58(myeccpoint + myhash[ :4 ])) else: hash160 = parse_as_address(c) hash160_unc = None if not hash160: sys.stderr.write("can't decode input %s\n" % c) sys.exit(1) print("hash160: %s" % b2h(hash160)) if hash160_unc: print(" uncompressed: %s" % b2h(hash160_unc)) print("Bitcoin address: %s" % encoding.hash160_sec_to_bitcoin_address(hash160)) if hash160_unc: print(" uncompressed: %s" % encoding.hash160_sec_to_bitcoin_address(hash160_unc))
def main(): parser = argparse.ArgumentParser(description="Bitcoin utilities.") parser.add_argument('-a', "--address", help='show as Bitcoin address', action='store_true') parser.add_argument('-1', "--hash160", help='show as hash 160', action='store_true') parser.add_argument('-v', "--verbose", help='dump all information available', action='store_true') parser.add_argument('-w', "--wif", help='show as Bitcoin WIF', action='store_true') parser.add_argument('-n', "--uncompressed", help='show in uncompressed form', action='store_true') parser.add_argument('item', help='a WIF, secret exponent, X/Y public pair, SEC (as hex), hash160 (as hex), Bitcoin address', nargs="+") args = parser.parse_args() for c in args.item: # figure out what it is: # - secret exponent # - WIF # - X/Y public key (base 10 or hex) # - sec # - hash160 # - Bitcoin address secret_exponent = parse_as_private_key(c) if secret_exponent: public_pair = ecdsa.public_pair_for_secret_exponent(secp256k1.generator_secp256k1, secret_exponent) print("secret exponent: %d" % secret_exponent) print(" hex: %x" % secret_exponent) print("WIF: %s" % encoding.secret_exponent_to_wif(secret_exponent, compressed=True)) print(" uncompressed: %s" % encoding.secret_exponent_to_wif(secret_exponent, compressed=False)) else: public_pair = parse_as_public_pair(c) if public_pair: bitcoin_address_uncompressed = encoding.public_pair_to_bitcoin_address(public_pair, compressed=False) bitcoin_address_compressed = encoding.public_pair_to_bitcoin_address(public_pair, compressed=True) print("public pair x: %d" % public_pair[0]) print("public pair y: %d" % public_pair[1]) print(" x as hex: %x" % public_pair[0]) print(" y as hex: %x" % public_pair[1]) print("y parity: %s" % "odd" if (public_pair[1] & 1) else "even") print("key pair as sec: %s" % b2h(encoding.public_pair_to_sec(public_pair, compressed=True))) s = b2h(encoding.public_pair_to_sec(public_pair, compressed=False)) print(" uncompressed: %s\\\n %s" % (s[:66], s[66:])) hash160 = encoding.public_pair_to_hash160_sec(public_pair, compressed=True) hash160_unc = encoding.public_pair_to_hash160_sec(public_pair, compressed=False) else: hash160 = parse_as_address(c) hash160_unc = None if not hash160: sys.stderr.write("can't decode input %s\n" % c) sys.exit(1) print("hash160: %s" % b2h(hash160)) if hash160_unc: print(" uncompressed: %s" % b2h(hash160_unc)) print("Bitcoin address: %s" % encoding.hash160_sec_to_bitcoin_address(hash160)) if hash160_unc: print(" uncompressed: %s" % encoding.hash160_sec_to_bitcoin_address(hash160_unc))
def do_test(exp_hex, wif, c_wif, public_pair_sec, c_public_pair_sec, address_b58, c_address_b58): secret_exponent = int(exp_hex, 16) sec = h2b(public_pair_sec) c_sec = h2b(c_public_pair_sec) self.assertEqual( secret_exponent_to_wif(secret_exponent, compressed=False), wif) self.assertEqual( secret_exponent_to_wif(secret_exponent, compressed=True), c_wif) exponent, compressed = wif_to_tuple_of_secret_exponent_compressed( wif) self.assertEqual(exponent, secret_exponent) self.assertFalse(compressed) exponent, compressed = wif_to_tuple_of_secret_exponent_compressed( c_wif) self.assertEqual(exponent, secret_exponent) self.assertTrue(compressed) public_pair = secret_exponent * secp256k1_generator pk_public_pair = sec_to_public_pair(sec) compressed = is_sec_compressed(sec) self.assertEqual(pk_public_pair, public_pair) self.assertFalse(is_sec_compressed(sec)) self.assertEqual( public_pair_to_sec(pk_public_pair, compressed=False), sec) pk_public_pair = sec_to_public_pair(c_sec) compressed = is_sec_compressed(c_sec) self.assertEqual(pk_public_pair, public_pair) self.assertTrue(compressed) self.assertEqual( public_pair_to_sec(pk_public_pair, compressed=True), c_sec) bca = public_pair_to_bitcoin_address(pk_public_pair, compressed=True) self.assertEqual(bca, c_address_b58) self.assertEqual( bitcoin_address_to_hash160_sec(c_address_b58), public_pair_to_hash160_sec(pk_public_pair, compressed=True)) bca = public_pair_to_bitcoin_address(pk_public_pair, compressed=False) self.assertEqual(bca, address_b58) self.assertEqual( bitcoin_address_to_hash160_sec(address_b58), public_pair_to_hash160_sec(pk_public_pair, compressed=False))
def generate_redeem_link(email): #Generate (Public, Private) key pair rand = os.urandom(32).encode('hex') secret_exponent = int("0x" + rand, 0) private_key = encoding.secret_exponent_to_wif(secret_exponent, compressed=True) public_pair = ecdsa.public_pair_for_secret_exponent( ecdsa.secp256k1.generator_secp256k1, secret_exponent) public_key1 = "04" + format(public_pair[0], 'x') + format( public_pair[1], 'x') #Only submit public_key/email to server post_request_data = {"public_key1": public_key1, "email": email} response = requests.post(SPLIT_KEY_API, data=post_request_data) result = response.json() btc_address = result.get("bitcoin_address") if btc_address: email_redeem_code(btc_address) redeem_url = "{}?key1={}&bitcoin_address={}".format( REDEEM_ENDPOINT, private_key, btc_address) return [email, btc_address, redeem_url] else: raise RuntimeError(result['message'])
def generate_redeem_link(email): #Generate (Public, Private) key pair rand = os.urandom(32).encode('hex') secret_exponent= int("0x"+rand, 0) % ecdsa.secp256k1._r private_key = encoding.secret_exponent_to_wif(secret_exponent, compressed=True) public_pair = ecdsa.public_pair_for_secret_exponent(ecdsa.secp256k1.generator_secp256k1,secret_exponent) public_key1 = "04" + format(public_pair[0], '064x') + format(public_pair[1], '064x') #Only submit public_key/email to server post_request_data = { "public_key1" : public_key1, "email" : email, "refund_time": REFUND_TIME} headers={'Authorization': 'Bearer {}'.format(API_KEY)} response = requests.post(SPLIT_KEY_API, data=post_request_data, headers=headers) result = response.json() btc_address = result.get("bitcoin_address") if btc_address: email_redeem_code(btc_address) redeem_url="{}?key1={}&bitcoin_address={}".format(REDEEM_ENDPOINT, private_key, btc_address) return dict(redeem_url = redeem_url, bitcoin_address = btc_address) else: raise RuntimeError(result['message'])
def gen_address(private_key, compressed=True): # private_key = codecs.encode(os.urandom(32), 'hex').decode() secret_exponent = int('0x' + private_key, 0) print('WIF: ' + encoding.secret_exponent_to_wif(secret_exponent, compressed=compressed)) public_pair = ecdsa.public_pair_for_secret_exponent(ecdsa.secp256k1.generator_secp256k1, secret_exponent) print('public pair:', public_pair) hash160 = encoding.public_pair_to_hash160_sec(public_pair, compressed=compressed) print("hash160: {}".format(hash160.hex())) return encoding.hash160_sec_to_bitcoin_address(hash160, address_prefix=b'\0')
def dumpprivkey(self, address, return_sec_exp=False): if is_valid_bitcoin_address(address) == False: return Exception("Invalid address %s" % address) try: secret_exponent = self.getsecretexponent(address) wif = secret_exponent_to_wif(secret_exponent) except: raise Exception("Unknown address: %s" % address) return wif
def dumpprivkey(self, address, return_sec_exp=False): if is_valid_bitcoin_address(address)==False: return Exception("Invalid address %s" % address) try: secret_exponent = self.getsecretexponent(address) wif = secret_exponent_to_wif(secret_exponent) except: raise Exception("Unknown address: %s" % address) return wif
def do_test(as_secret_exponent, as_wif, is_compressed): self.assertEqual( as_wif, encoding.secret_exponent_to_wif(as_secret_exponent, compressed=is_compressed)) se, comp = encoding.wif_to_tuple_of_secret_exponent_compressed( as_wif) self.assertEqual(se, as_secret_exponent) self.assertEqual(comp, is_compressed) self.assertTrue(encoding.is_valid_wif(as_wif))
def do_test(exp_hex, wif, c_wif, public_pair_sec, c_public_pair_sec, address_b58, c_address_b58): secret_exponent = int(exp_hex, 16) sec = h2b(public_pair_sec) c_sec = h2b(c_public_pair_sec) self.assertEqual(secret_exponent_to_wif(secret_exponent, compressed=False), wif) self.assertEqual(secret_exponent_to_wif(secret_exponent, compressed=True), c_wif) exponent, compressed = wif_to_tuple_of_secret_exponent_compressed(wif) self.assertEqual(exponent, secret_exponent) self.assertFalse(compressed) exponent, compressed = wif_to_tuple_of_secret_exponent_compressed(c_wif) self.assertEqual(exponent, secret_exponent) self.assertTrue(compressed) public_pair = secret_exponent * secp256k1_generator pk_public_pair = sec_to_public_pair(sec) compressed = is_sec_compressed(sec) self.assertEqual(pk_public_pair, public_pair) self.assertFalse(is_sec_compressed(sec)) self.assertEqual(public_pair_to_sec(pk_public_pair, compressed=False), sec) pk_public_pair = sec_to_public_pair(c_sec) compressed = is_sec_compressed(c_sec) self.assertEqual(pk_public_pair, public_pair) self.assertTrue(compressed) self.assertEqual(public_pair_to_sec(pk_public_pair, compressed=True), c_sec) bca = public_pair_to_bitcoin_address(pk_public_pair, compressed=True) self.assertEqual(bca, c_address_b58) self.assertEqual(bitcoin_address_to_hash160_sec(c_address_b58), public_pair_to_hash160_sec(pk_public_pair, compressed=True)) bca = public_pair_to_bitcoin_address(pk_public_pair, compressed=False) self.assertEqual(bca, address_b58) self.assertEqual(bitcoin_address_to_hash160_sec(address_b58), public_pair_to_hash160_sec(pk_public_pair, compressed=False))
def wif(self, use_uncompressed=None): """ Return the WIF representation of this key, if available. If use_uncompressed is not set, the preferred representation is returned. """ wif_prefix = wif_prefix_for_netcode(self._netcode) secret_exponent = self.secret_exponent() if secret_exponent is None: return None return secret_exponent_to_wif(secret_exponent, compressed=not self._use_uncompressed(use_uncompressed), wif_prefix=wif_prefix)
def privkey_to_wif(privkey, netcode="BTC"): """ Get private key from bitcoin wif. Args: privkey (str): Hex encoded private key Return: str: Private key encode in bitcoin wif format. """ prefix = networks.wif_prefix_for_netcode(netcode) secret_exponent = encoding.from_bytes_32(h2b(privkey)) return encoding.secret_exponent_to_wif(secret_exponent, wif_prefix=prefix)
def _calculate_all(self): for attr in "_secret_exponent _public_pair _wif_uncompressed _wif_compressed _sec_compressed" \ " _sec_uncompressed _hash160_compressed _hash160_uncompressed _address_compressed" \ " _address_uncompressed _netcode".split(): setattr(self, attr, getattr(self, attr, None)) if self._hierarchical_wallet: if self._hierarchical_wallet.is_private: self._secret_exponent = self._hierarchical_wallet.secret_exponent else: self._public_pair = self._hierarchical_wallet.public_pair self._netcode = self._hierarchical_wallet.netcode wif_prefix = wif_prefix_for_netcode(self._netcode) if self._secret_exponent: self._wif_uncompressed = secret_exponent_to_wif( self._secret_exponent, compressed=False, wif_prefix=wif_prefix) self._wif_compressed = secret_exponent_to_wif( self._secret_exponent, compressed=True, wif_prefix=wif_prefix) self._public_pair = ecdsa.public_pair_for_secret_exponent( ecdsa.generator_secp256k1, self._secret_exponent) if self._public_pair: self._sec_compressed = public_pair_to_sec(self._public_pair, compressed=True) self._sec_uncompressed = public_pair_to_sec(self._public_pair, compressed=False) self._hash160_compressed = hash160(self._sec_compressed) self._hash160_uncompressed = hash160(self._sec_uncompressed) address_prefix = address_prefix_for_netcode(self._netcode) if self._hash160_compressed: self._address_compressed = hash160_sec_to_bitcoin_address( self._hash160_compressed, address_prefix=address_prefix) if self._hash160_uncompressed: self._address_uncompressed = hash160_sec_to_bitcoin_address( self._hash160_uncompressed, address_prefix=address_prefix)
def do_test(exp_hex, wif, c_wif, public_pair_sec, c_public_pair_sec, address_b58, c_address_b58): secret_exponent = int(exp_hex, 16) sec = binascii.unhexlify(public_pair_sec) c_sec = binascii.unhexlify(c_public_pair_sec) self.assertEqual(secret_exponent_to_wif(secret_exponent, compressed=False), wif) self.assertEqual(secret_exponent_to_wif(secret_exponent, compressed=True), c_wif) exponent, compressed = wif_to_tuple_of_secret_exponent_compressed(wif) self.assertEqual(exponent, secret_exponent) self.assertFalse(compressed) exponent, compressed = wif_to_tuple_of_secret_exponent_compressed(c_wif) self.assertEqual(exponent, secret_exponent) self.assertTrue(compressed) public_pair = public_pair_for_secret_exponent(generator_secp256k1, secret_exponent) pk_public_pair = public_pair_from_sec(sec) compressed = is_sec_compressed(sec) self.assertEqual(pk_public_pair, public_pair) self.assertFalse(is_sec_compressed(sec)) self.assertEqual(public_pair_to_sec(pk_public_pair, compressed=False), sec) pk_public_pair = public_pair_from_sec(c_sec) compressed = is_sec_compressed(c_sec) self.assertEqual(pk_public_pair, public_pair) self.assertTrue(compressed) self.assertEqual(public_pair_to_sec(pk_public_pair, compressed=True), c_sec) bca = public_pair_to_bitcoin_address(pk_public_pair, compressed=True) self.assertEqual(bca, c_address_b58) self.assertEqual(bitcoin_address_to_ripemd160_sha_sec(c_address_b58), public_pair_to_ripemd160_sha_sec(pk_public_pair, compressed=True)) bca = public_pair_to_bitcoin_address(pk_public_pair, compressed=False) self.assertEqual(bca, address_b58) self.assertEqual(bitcoin_address_to_ripemd160_sha_sec(address_b58), public_pair_to_ripemd160_sha_sec(pk_public_pair, compressed=False))
def gen_address(private_key, compressed=True): # private_key = codecs.encode(os.urandom(32), 'hex').decode() secret_exponent = int('0x' + private_key, 0) print('WIF: ' + encoding.secret_exponent_to_wif(secret_exponent, compressed=compressed)) public_pair = ecdsa.public_pair_for_secret_exponent( ecdsa.secp256k1.generator_secp256k1, secret_exponent) print('public pair:', public_pair) hash160 = encoding.public_pair_to_hash160_sec(public_pair, compressed=compressed) print("hash160: {}".format(hash160.hex())) return encoding.hash160_sec_to_bitcoin_address(hash160, address_prefix=b'\0')
def GenerateKeys(indata): #Secret integer if indata == '0': k = random.randrange( 1, 1000000 ) #Valde bara mellan 1-1000,000 som ex. randrange är ju inte totalt random heller.. else: k = int(indata) #Kodar om secret integer till uncompressed public key secp = ecdsa.secp256k1 G = secp.generator_secp256k1 P = k * G #Kodar om P till compressed format x = '%064x' % P.x() comp_pk = ('02' if P.x() % 2 == 0 else '03') + x #Kodar om secret integer till wif format wif = encoding.secret_exponent_to_wif( k ) #Skrev ingen kod för att göra om till wif då det fanns en färdig metod för det.. print("Public key") print(" Public uncompressed key is:") print(" x:", P.x()) print(" y:", P.y()) print(" Public compressed key is:") print(" ", comp_pk) print("------------") print("Private key") print(" Tal: ", k) print(" Hex: ", hex(k)[2:]) print(" Wif: ", wif) publicPair = [ P.x(), P.y() ] #Array som sparar X,Y för att kunna kodas om till bitcoin address print("------------------") print( "Bitcoin Address: " ) #Samma sak här, finns färdiga metoder för att koda om till bitcoin address print(" Uncompressed: ", encoding.public_pair_to_bitcoin_address(publicPair, False)) print(" Compressed: ", encoding.public_pair_to_bitcoin_address(publicPair, True))
def _gen (self): logger.debug ('Generating entropy for new wallet...') # Generate entropy entropy = bytearray() try: entropy.extend(open("/dev/random", "rb").read(64)) except Exception: print("warning: can't use /dev/random as entropy source") entropy = bytes(entropy) if len(entropy) < 64: raise OSError("can't find sources of entropy") secret_exponent = int(binascii.hexlify (entropy)[0:32], 16) wif = secret_exponent_to_wif(secret_exponent, compressed=True, wif_prefix=wif_prefix_for_netcode (self.chain)) key = Key (secret_exponent=secret_exponent, netcode=self.chain) return (str (key.address ()), str (key.wif ()))
def warp(self, passphrase, salt=""): """ Return dictionary of WarpWallet public and private keys corresponding to the given passphrase and salt. """ s1 = binascii.hexlify(self._scrypt(passphrase, salt)) out = self._pbkdf2(passphrase, salt) s2 = binascii.hexlify(out) base = binascii.unhexlify(s1) s3 = binascii.hexlify(self._sxor(base,out)) secret_exponent = int(s3, 16) public_pair = ecdsa.public_pair_for_secret_exponent(secp256k1.generator_secp256k1, secret_exponent) private_key = encoding.secret_exponent_to_wif(secret_exponent, compressed=False) public_key = encoding.public_pair_to_bitcoin_address(public_pair, compressed=False) out = { "keys" : { "private_key" : private_key, "public_key" : public_key }, "seeds" : [s1, s2, s3], "passphrase" : passphrase, "salt" : salt } return out
import unittest from pycoin.ecdsa import generator_secp256k1, public_pair_for_secret_exponent from pycoin.encoding import public_pair_to_bitcoin_address, secret_exponent_to_wif from pycoin.tx.exceptions import BadSpendableError from pycoin.tx.tx_utils import create_signed_tx from pycoin.tx.Spendable import Spendable from pycoin.ui import standard_tx_out_script BITCOIN_ADDRESSES = [public_pair_to_bitcoin_address( public_pair_for_secret_exponent(generator_secp256k1, i)) for i in range(1, 21)] WIFS = [secret_exponent_to_wif(i) for i in range(1, 21)] FAKE_HASHES = [hashlib.sha256(struct.pack("Q", idx)).digest() for idx in range(100)] class SpendTest(unittest.TestCase): def test_simple_spend(self): FEE = 10000 # create a fake Spendable COIN_VALUE = 100000000 spendables = [Spendable(COIN_VALUE, standard_tx_out_script(BITCOIN_ADDRESSES[0]), FAKE_HASHES[1], 0)] EXPECTED_IDS = [
def get_private_key(self): return secret_exponent_to_wif(self.rawPrivKey, False, self.testnet)
print() print("CECKey example - ", my_netcode) print("Pubkey Addr Ver: ", bitcoin.params.BASE58_PREFIXES['PUBKEY_ADDR'], ", Secret Key Ver: ", bitcoin.params.BASE58_PREFIXES['SECRET_KEY']) # use CECKey class cec_key = CECKey() #cec_key.set_secretbytes(privkey_bytes) random_nbr = 1 #util.randrange(ecdsa.generator_secp256k1.order()) my_secret_exp = b2h(encoding.to_bytes_32(random_nbr)) cec_key.set_secretbytes(bitcoin.core.x(my_secret_exp)) print("Private Key dec: ", random_nbr) print("Private Key hex: ", my_secret_exp) privkey_wif = encoding.secret_exponent_to_wif(eval('0x' + my_secret_exp), wif_prefix=my_privkey_prefix) print("Private key WIF: ", privkey_wif) privkey_wif = encoding.secret_exponent_to_wif(eval('0x' + my_secret_exp), False, wif_prefix=my_privkey_prefix) print(" uncompressed: ", privkey_wif) cec_key.set_compressed(True) print() pubkey_pair = encoding.sec_to_public_pair(cec_key.get_pubkey()) print("Public key pair: ", pubkey_pair) (pub_key_x, pub_key_y) = pubkey_pair compressed_indicator = True if (pub_key_y % 2) == 0 else False print("Public key y parity? ", 'even' if compressed_indicator else 'odd')
def get_private_key(self): return secret_exponent_to_wif(self.rawPrivKey, False, self.prefix)
#Below generate correct public address as found with money import hashlib from pycoin import ecdsa, encoding import os import codecs if __name__ == '__main__': #rand = codecs.encode(os.urandom(32), 'hex').decode() #secret_exponent= int('0x'+rand, 0) secret_exponent = int(hp, 16) print('WIF: ' + encoding.secret_exponent_to_wif(secret_exponent, compressed=False)) public_pair = ecdsa.public_pair_for_secret_exponent( ecdsa.secp256k1.generator_secp256k1, secret_exponent) hash160 = encoding.public_pair_to_hash160_sec(public_pair, compressed=True) codecs.encode(hash160, 'hex') print('Bitcoin address: %s' % encoding.hash160_sec_to_bitcoin_address(hash160)) with open('../../Mining/dict/UrbanDictionary.txt', 'r') as f: contents = f.readlines() fout = open('privaddr-pair.txt', 'w') i = 0
def wif(self, compressed=True): """Return the base58 representation (WIF format) for the private key """ return secret_exponent_to_wif(self.exponent)
def do_test(as_secret_exponent, as_wif, is_compressed): self.assertEqual(as_wif, encoding.secret_exponent_to_wif(as_secret_exponent, compressed=is_compressed)) se, comp = encoding.wif_to_tuple_of_secret_exponent_compressed(as_wif) self.assertEqual(se, as_secret_exponent) self.assertEqual(comp, is_compressed) self.assertTrue(encoding.is_valid_wif(as_wif))
def main(): parser = argparse.ArgumentParser(description="Bitcoin utilities.") parser.add_argument("-a", "--address", help="show as Bitcoin address", action="store_true") parser.add_argument("-1", "--hash160", help="show as hash 160", action="store_true") parser.add_argument("-v", "--verbose", help="dump all information available", action="store_true") parser.add_argument("-w", "--wif", help="show as Bitcoin WIF", action="store_true") parser.add_argument("-n", "--uncompressed", help="show in uncompressed form", action="store_true") parser.add_argument("-j", "--json", help="output in JSON format", action="store_true") parser.add_argument("-t", help="interpret fields as test values", action="store_true") parser.add_argument("-ltc", help="generate LTC address", action="store_true") parser.add_argument("-doge", help="generate DOGE address", action="store_true") parser.add_argument( "item", help="a WIF, secret exponent, X/Y public pair, SEC (as hex), hash160 (as hex), Bitcoin address", nargs="+", ) args = parser.parse_args() if args.ltc: args.t = "litecoin" else: if args.doge: if args.t: args.t = "dogetest" else: args.t = "doge" if args.json: print("{") argcount = len(args.item) i = 0 for c in args.item: i = i + 1 print(' "%s" : { ' % c) secret_exponent = parse_as_private_key(c) if secret_exponent: public_pair = ecdsa.public_pair_for_secret_exponent(secp256k1.generator_secp256k1, secret_exponent) print(' "secret_exponent" : "%d",' % secret_exponent) print(' "secret_exponent_hex" : "%x",' % secret_exponent) print( ' "wif" : "%s",' % encoding.secret_exponent_to_wif(secret_exponent, compressed=True, is_test=args.t) ) print( ' "wif_uncompressed" : "%s",' % encoding.secret_exponent_to_wif(secret_exponent, compressed=False, is_test=args.t) ) else: public_pair = parse_as_public_pair(c) if public_pair: bitcoin_address_uncompressed = encoding.public_pair_to_bitcoin_address( public_pair, compressed=False, is_test=args.t ) bitcoin_address_compressed = encoding.public_pair_to_bitcoin_address( public_pair, compressed=True, is_test=args.t ) print(' "public_pair_x" : "%d",' % public_pair[0]) print(' "public_pair_y" : "%d",' % public_pair[1]) print(' "x_as_hex" : "%x",' % public_pair[0]) print(' "y_as_hex" : "%x",' % public_pair[1]) if public_pair[1] & 1: print(' "y_parity" : "odd",') else: print(' "y_parity" : "even",') print(' "key_pair_as_sec" : "%s",' % b2h(encoding.public_pair_to_sec(public_pair, compressed=True))) hash160 = encoding.public_pair_to_hash160_sec(public_pair, compressed=True) hash160_unc = encoding.public_pair_to_hash160_sec(public_pair, compressed=False) else: hash160 = parse_as_address(c) hash160_unc = None if not hash160: print(' "error" : "cannot decode input %s",' % c) print(' "hash160" : "%s",' % b2h(hash160)) if hash160_unc: print(' "hash160_uncompressed" : "%s",' % b2h(hash160_unc)) if hash160_unc: # print(' "bitcoind_addr_uncompressed" : "%s",' % encoding.hash160_sec_to_bitcoin_address(hash160_unc)) print(' "bitcoind_addr_uncompressed" : "%s",' % bitcoin_address_uncompressed) # print(' "bitcoin_addr" : "%s"' % encoding.hash160_sec_to_bitcoin_address(hash160)) print(' "bitcoin_addr" : "%s"' % bitcoin_address_compressed) if i == argcount: print(" }") else: print(" },") print("}") else: for c in args.item: # figure out what it is: # - secret exponent # - WIF # - X/Y public key (base 10 or hex) # - sec # - hash160 # - Bitcoin address secret_exponent = parse_as_private_key(c) if secret_exponent: public_pair = ecdsa.public_pair_for_secret_exponent(secp256k1.generator_secp256k1, secret_exponent) print("secret exponent: %d" % secret_exponent) print(" hex: %x" % secret_exponent) print("WIF: %s" % encoding.secret_exponent_to_wif(secret_exponent, compressed=True)) print(" uncompressed: %s" % encoding.secret_exponent_to_wif(secret_exponent, compressed=False)) else: public_pair = parse_as_public_pair(c) if public_pair: bitcoin_address_uncompressed = encoding.public_pair_to_bitcoin_address(public_pair, compressed=False) bitcoin_address_compressed = encoding.public_pair_to_bitcoin_address(public_pair, compressed=True) print("public pair x: %d" % public_pair[0]) print("public pair y: %d" % public_pair[1]) print(" x as hex: %x" % public_pair[0]) print(" y as hex: %x" % public_pair[1]) print("y parity: %s" % "odd" if (public_pair[1] & 1) else "even") print("key pair as sec: %s" % b2h(encoding.public_pair_to_sec(public_pair, compressed=True))) s = b2h(encoding.public_pair_to_sec(public_pair, compressed=False)) print(" uncompressed: %s\\\n %s" % (s[:66], s[66:])) hash160 = encoding.public_pair_to_hash160_sec(public_pair, compressed=True) hash160_unc = encoding.public_pair_to_hash160_sec(public_pair, compressed=False) else: hash160 = parse_as_address(c) hash160_unc = None if not hash160: sys.stderr.write("can't decode input %s\n" % c) sys.exit(1) print("hash160: %s" % b2h(hash160)) if hash160_unc: print(" uncompressed: %s" % b2h(hash160_unc)) print("Bitcoin address: %s" % encoding.hash160_sec_to_bitcoin_address(hash160)) if hash160_unc: print(" uncompressed: %s" % encoding.hash160_sec_to_bitcoin_address(hash160_unc))
from pycoin.ecdsa import generator_secp256k1, public_pair_for_secret_exponent from pycoin.encoding import public_pair_to_bitcoin_address, secret_exponent_to_wif from pycoin.tx.Tx import BadSpendableError from pycoin.tx.TxOut import standard_tx_out_script from pycoin.tx.tx_utils import create_signed_tx from pycoin.tx.Spendable import Spendable BITCOIN_ADDRESSES = [ public_pair_to_bitcoin_address( public_pair_for_secret_exponent(generator_secp256k1, i)) for i in range(1, 21) ] WIFS = [secret_exponent_to_wif(i) for i in range(1, 21)] FAKE_HASHES = [ hashlib.sha256(struct.pack("Q", idx)).digest() for idx in range(100) ] class SpendTest(unittest.TestCase): def test_simple_spend(self): FEE = 10000 # create a fake Spendable COIN_VALUE = 100000000 spendables = [ Spendable(COIN_VALUE, standard_tx_out_script(BITCOIN_ADDRESSES[0]),