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 create_addr():
priv = codecs.encode(os.urandom(32), 'hex').decode()
secret_exponent= int('0x'+rand, 0)
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)
addr = encoding.hash160_sec_to_bitcoin_address(hash160)
return addr, priv
def address_for_pay_to_script(script, netcode=None):
if netcode is None:
netcode = get_current_netcode()
address_prefix = pay_to_script_prefix_for_netcode(netcode)
if address_prefix:
return encoding.hash160_sec_to_bitcoin_address(
encoding.hash160(script), address_prefix=address_prefix)
return None
def address (self, addrversion=b'\0'):
if not hasattr(self, '_address'):
self._address_h160 = ProxyTxOut.address_h160_from_script(self.script)
if self._address_h160 is None:
self._address = None
else:
self._address = hash160_sec_to_bitcoin_address(self._address_h160, addrversion=addrversion)
return self._address
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 address(self, address_prefix=b'\0'):
if self.is_coinbase():
return "(coinbase)"
# attempt to return the source address
sec = self.public_key_sec()
if sec:
bitcoin_address = encoding.hash160_sec_to_bitcoin_address(
encoding.hash160(sec), address_prefix=address_prefix)
return bitcoin_address
return "(unknown)"
def address(self, use_uncompressed=None):
"""
Return the public address representation of this key, if available.
If use_uncompressed is not set, the preferred representation is returned.
"""
address_prefix = address_prefix_for_netcode(self._netcode)
hash160 = self.hash160(use_uncompressed=use_uncompressed)
if hash160:
return hash160_sec_to_bitcoin_address(hash160, address_prefix=address_prefix)
return None
def address(self, use_uncompressed=None):
"""
Return the public address representation of this key, if available.
If use_uncompressed is not set, the preferred representation is returned.
"""
address_prefix = address_prefix_for_netcode(self._netcode)
hash160 = self.hash160(use_uncompressed=use_uncompressed)
if hash160:
return hash160_sec_to_bitcoin_address(hash160, address_prefix=address_prefix)
return None
def do_test(as_public_pair, as_sec, is_compressed, as_hash160_sec, as_bitcoin_address):
self.assertEqual(encoding.sec_to_public_pair(as_sec), as_public_pair)
self.assertEqual(encoding.public_pair_to_sec(as_public_pair, compressed=is_compressed), as_sec)
self.assertEqual(encoding.is_sec_compressed(as_sec), is_compressed)
self.assertEqual(encoding.public_pair_to_hash160_sec(as_public_pair, compressed=is_compressed),
as_hash160_sec)
self.assertEqual(encoding.hash160_sec_to_bitcoin_address(as_hash160_sec), as_bitcoin_address)
self.assertEqual(encoding.public_pair_to_bitcoin_address(as_public_pair, compressed=is_compressed), as_bitcoin_address)
self.assertTrue(encoding.is_valid_bitcoin_address(as_bitcoin_address))
bad_address = as_bitcoin_address[:17] + chr(ord(as_bitcoin_address[17]) + 1) + as_bitcoin_address[18:]
self.assertFalse(encoding.is_valid_bitcoin_address(bad_address))
def do_test(as_public_pair, as_sec, is_compressed, as_hash160_sec, as_bitcoin_address):
self.assertEqual(encoding.sec_to_public_pair(as_sec), as_public_pair)
self.assertEqual(encoding.public_pair_to_sec(as_public_pair, compressed=is_compressed), as_sec)
self.assertEqual(encoding.is_sec_compressed(as_sec), is_compressed)
self.assertEqual(encoding.public_pair_to_hash160_sec(as_public_pair, compressed=is_compressed),
as_hash160_sec)
self.assertEqual(encoding.hash160_sec_to_bitcoin_address(as_hash160_sec), as_bitcoin_address)
self.assertEqual(encoding.public_pair_to_bitcoin_address(as_public_pair, compressed=is_compressed), as_bitcoin_address)
self.assertTrue(encoding.is_valid_bitcoin_address(as_bitcoin_address))
bad_address = as_bitcoin_address[:17] + chr(ord(as_bitcoin_address[17]) + 1) + as_bitcoin_address[18:]
self.assertFalse(encoding.is_valid_bitcoin_address(bad_address))
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 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 _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 bitcoin_address_for_script(self, is_test=False):
try:
r = self.match_script_to_templates()
if len(r) != 1 or len(r[0]) != 2:
return None
if r[0][0] == opcodes.OP_PUBKEYHASH:
return hash160_sec_to_bitcoin_address(r[0][1], is_test=is_test)
if r[0][0] == opcodes.OP_PUBKEY:
sec = r[0][1]
return public_pair_to_bitcoin_address(
sec_to_public_pair(sec),
compressed=is_sec_compressed(sec),
is_test=is_test)
except SolvingError:
pass
return None
def bitcoin_address_for_script(self, is_test=False):
try:
r = self.match_script_to_templates()
if len(r) != 1 or len(r[0]) != 2:
return None
if r[0][0] == opcodes.OP_PUBKEYHASH:
return hash160_sec_to_bitcoin_address(r[0][1], is_test=is_test)
if r[0][0] == opcodes.OP_PUBKEY:
sec = r[0][1]
return public_pair_to_bitcoin_address(
sec_to_public_pair(sec),
compressed=is_sec_compressed(sec),
is_test=is_test)
except SolvingError:
pass
return None
def __call__(self, tx_out_script, signature_hash, signature_type):
"""Figure out how to create a signature for the incoming transaction, and sign it.
tx_out_script: the tx_out script that needs to be "solved"
signature_hash: the bignum hash value of the new transaction reassigning the coins
signature_type: always SIGHASH_ALL (1)
"""
if signature_hash == 0:
raise SolvingError("signature_hash can't be 0")
tx_script = TxScript(tx_out_script)
opcode_value_list = tx_script.match_script_to_templates()
ba = bytearray()
compressed = True
for opcode, v in opcode_value_list:
if opcode == opcodes.OP_PUBKEY:
public_pair = sec_to_public_pair(v)
bitcoin_address = public_pair_to_bitcoin_address(
public_pair, compressed=compressed)
elif opcode == opcodes.OP_PUBKEYHASH:
bitcoin_address = hash160_sec_to_bitcoin_address(v)
else:
raise SolvingError("can't determine how to sign this script")
secret_exponent = self.wallet.getsecretexponent(bitcoin_address)
r, s = ecdsa.sign(ecdsa.generator_secp256k1, secret_exponent,
signature_hash)
sig = der.sigencode_der(r, s) + bytes_from_int(signature_type)
ba += tools.compile(binascii.hexlify(sig).decode("utf8"))
if opcode == opcodes.OP_PUBKEYHASH:
public_pair = ecdsa.public_pair_for_secret_exponent(
ecdsa.generator_secp256k1, secret_exponent)
ba += tools.compile(
binascii.hexlify(
public_pair_to_sec(
public_pair,
compressed=compressed)).decode("utf8"))
return bytes(ba)
def address(self, use_uncompressed=None):
"""
Return the public address representation of this key, if available.
If use_uncompressed is not set, the preferred representation is returned.
"""
hash_160 = self.hash160(use_uncompressed=use_uncompressed)
if hash_160:
is_p2pwk = address_wit_for_netcode(self._netcode)
if is_p2pwk:
witness = ScriptPayToAddressWit(b'\0', hash_160)
return witness.info(self._netcode)['address_f']()
is_p2pwk_in_p2sh = pay_to_script_wit_for_netcode(self._netcode)
if is_p2pwk_in_p2sh:
address_prefix = pay_to_script_prefix_for_netcode(
self._netcode)
wit_script = ScriptPayToAddressWit(b'\0', hash_160).script()
hash_160 = hash160(wit_script)
else:
address_prefix = address_prefix_for_netcode(self._netcode)
return hash160_sec_to_bitcoin_address(
hash_160, address_prefix=address_prefix)
return None
def __call__(self, tx_out_script, signature_hash, signature_type):
"""Figure out how to create a signature for the incoming transaction, and sign it.
tx_out_script: the tx_out script that needs to be "solved"
signature_hash: the bignum hash value of the new transaction reassigning the coins
signature_type: always SIGHASH_ALL (1)
"""
if signature_hash == 0:
raise SolvingError("signature_hash can't be 0")
tx_script = TxScript(tx_out_script)
opcode_value_list = tx_script.match_script_to_templates()
ba = bytearray()
compressed = True
for opcode, v in opcode_value_list:
if opcode == opcodes.OP_PUBKEY:
public_pair = sec_to_public_pair(v)
bitcoin_address = public_pair_to_bitcoin_address(public_pair, compressed=compressed)
elif opcode == opcodes.OP_PUBKEYHASH:
bitcoin_address = hash160_sec_to_bitcoin_address(v)
else:
raise SolvingError("can't determine how to sign this script")
secret_exponent = self.wallet.getsecretexponent(bitcoin_address)
r, s = ecdsa.sign(ecdsa.generator_secp256k1, secret_exponent, signature_hash)
sig = der.sigencode_der(r, s) + bytes_from_int(signature_type)
ba += tools.compile(binascii.hexlify(sig).decode("utf8"))
if opcode == opcodes.OP_PUBKEYHASH:
public_pair = ecdsa.public_pair_for_secret_exponent(ecdsa.generator_secp256k1, secret_exponent)
ba += tools.compile(
binascii.hexlify(public_pair_to_sec(public_pair, compressed=compressed)).decode("utf8")
)
return bytes(ba)
from pycoin.key.bip32 import Wallet
from pycoin.encoding import public_pair_to_hash160_sec, hash160_sec_to_bitcoin_address
from pycoin.networks import address_prefix_for_netcode, alternate_hash_for_netcode
from binascii import hexlify
import bitcoinrpc
import socket
secret = os.urandom(64)
wallet = Wallet.from_master_secret(bytes(secret), 'BLC')
sec = public_pair_to_hash160_sec(wallet.public_pair)
pubkey = ''.join('{:02x}'.format(ord(x)) for x in sec)
addr_blc = hash160_sec_to_bitcoin_address(
sec,
address_prefix=address_prefix_for_netcode('BLC'),
internal_hash=alternate_hash_for_netcode('BLC'))
addr_pho = hash160_sec_to_bitcoin_address(
sec,
address_prefix=address_prefix_for_netcode('PHO'),
internal_hash=alternate_hash_for_netcode('PHO'))
addr_bbtc = hash160_sec_to_bitcoin_address(
sec,
address_prefix=address_prefix_for_netcode('BBTC'),
internal_hash=alternate_hash_for_netcode('BBTC'))
addr_xdq = hash160_sec_to_bitcoin_address(
sec,
address_prefix=address_prefix_for_netcode('XDQ'),
internal_hash=alternate_hash_for_netcode('XDQ'))
addr_elt = hash160_sec_to_bitcoin_address(
sec,
def gen_address_from_160(hash160):
return encoding.hash160_sec_to_bitcoin_address(bytes.fromhex(hash160))
def change_prefix(address, new_prefix):
return hash160_sec_to_bitcoin_address(Key.from_text(address).hash160(),
address_prefix=new_prefix)
def _hash160_to_address(testnet, hash160):
prefix = b'\x6f' if testnet else b"\0"
return hash160_sec_to_bitcoin_address(hash160, address_prefix=prefix)
def add_address_annotations(annotations, hash160_blob, address_prefix):
address = hash160_sec_to_bitcoin_address(hash160_blob,
address_prefix=address_prefix)
annotations.append("%s... corresponds to %s" %
(b2h(hash160_blob)[:12], address))
def get_address_repr(self):
data = self.digest.decode("hex")
lpart = data[:20]
rpart = data[20:] + ("\x00" * 8)
return [hash160_sec_to_bitcoin_address(part) for part in [lpart, rpart]]
#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
for l in contents:
priv = seed2hpriv(l)
secret_exponent = int(priv, 16)
wif = encoding.secret_exponent_to_wif(secret_exponent,
compressed=False)
public_pair = ecdsa.public_pair_for_secret_exponent(
ecdsa.secp256k1.generator_secp256k1, secret_exponent)
def raw_to_address(self, raw_address):
prefix = self.testnet and b'\x32' or b"\x32"
return hash160_sec_to_bitcoin_address(raw_address,
address_prefix=prefix)
def raw_to_address(self, raw_address):
prefix = self.testnet and b'\x6f' or b"\0"
return hash160_sec_to_bitcoin_address(raw_address,
address_prefix=prefix)
def gen_address_from_160(hash160):
return encoding.hash160_sec_to_bitcoin_address(bytes.fromhex(hash160))
def public_pair_to_address(testnet, public_pair, compressed):
prefix = b'\x6f' if testnet else b"\0"
hash160 = public_pair_to_hash160_sec(public_pair, compressed=compressed)
return hash160_sec_to_bitcoin_address(hash160, address_prefix=prefix)
def raw_to_address(self, raw_address):
return hash160_sec_to_bitcoin_address(raw_address,
is_test=self.testnet)
import os
from pycoin.key.bip32 import Wallet
from pycoin.encoding import public_pair_to_hash160_sec, hash160_sec_to_bitcoin_address
from pycoin.networks import address_prefix_for_netcode, alternate_hash_for_netcode
from binascii import hexlify
import bitcoinrpc
import socket
secret = os.urandom(64)
wallet = Wallet.from_master_secret(bytes(secret), 'BLC')
sec = public_pair_to_hash160_sec(wallet.public_pair)
pubkey = ''.join('{:02x}'.format(ord(x)) for x in sec)
addr_blc = hash160_sec_to_bitcoin_address(sec, address_prefix=address_prefix_for_netcode('BLC'), internal_hash=alternate_hash_for_netcode('BLC'))
addr_pho = hash160_sec_to_bitcoin_address(sec, address_prefix=address_prefix_for_netcode('PHO'), internal_hash=alternate_hash_for_netcode('PHO'))
addr_bbtc = hash160_sec_to_bitcoin_address(sec, address_prefix=address_prefix_for_netcode('BBTC'), internal_hash=alternate_hash_for_netcode('BBTC'))
addr_xdq = hash160_sec_to_bitcoin_address(sec, address_prefix=address_prefix_for_netcode('XDQ'), internal_hash=alternate_hash_for_netcode('XDQ'))
addr_elt = hash160_sec_to_bitcoin_address(sec, address_prefix=address_prefix_for_netcode('ELT'), internal_hash=alternate_hash_for_netcode('ELT'))
addr_umo = hash160_sec_to_bitcoin_address(sec, address_prefix=address_prefix_for_netcode('UMO'), internal_hash=alternate_hash_for_netcode('UMO'))
addresses = {
'blakecoin': addr_blc,
'photon': addr_pho,
'blakebitcoin': addr_bbtc,
'dirac': addr_xdq,
'electron': addr_elt,
'universalmolecule': addr_umo
}
def add_address_annotations(annotations, hash160_blob, address_prefix):
address = hash160_sec_to_bitcoin_address(hash160_blob, address_prefix=address_prefix)
annotations.append("%s... corresponds to %s" % (b2h(hash160_blob)[:12], address))
print("Public key y parity? ", 'even' if compressed_indicator else 'odd')
#print("Private key hexlify: ", hexlify(cec_key.get_privkey()))
print("Public key hex: ", bitcoin.core.b2x(cec_key.get_pubkey()))
cec_key.set_compressed(False)
print(" uncompressed: ", bitcoin.core.b2x(cec_key.get_pubkey()))
addr_compressed = encoding.public_pair_to_bitcoin_address(
pubkey_pair, True, address_prefix=my_pubaddr_prefix)
addr_uncompressed = encoding.public_pair_to_bitcoin_address(
pubkey_pair, False, address_prefix=my_pubaddr_prefix)
# convert public key pair to public key to address
pubkey_hashed = encoding.public_pair_to_hash160_sec(pubkey_pair, True)
print("Public key hash160: ", bitcoin.core.b2x(pubkey_hashed))
pubkey_addr = encoding.hash160_sec_to_bitcoin_address(
pubkey_hashed, address_prefix=my_pubaddr_prefix)
assert (addr_compressed == pubkey_addr)
pubkey_hashed = encoding.public_pair_to_hash160_sec(pubkey_pair, False)
print(" uncompressed: ", bitcoin.core.b2x(pubkey_hashed))
pubkey_addr = encoding.hash160_sec_to_bitcoin_address(
pubkey_hashed, address_prefix=my_pubaddr_prefix)
assert (addr_uncompressed == pubkey_addr)
print("Bitcoin Address: ", addr_compressed)
print(" uncompressed: ", addr_uncompressed)
assert (encoding.is_valid_bitcoin_address(
addr_compressed, allowable_prefixes=my_pubaddr_prefix))
assert (encoding.is_valid_bitcoin_address(
addr_uncompressed, allowable_prefixes=my_pubaddr_prefix))
print()
def address_for_pay_to_script(script, netcode=None):
if netcode is None:
netcode = get_current_netcode()
address_prefix = pay_to_script_prefix_for_netcode(netcode)
return encoding.hash160_sec_to_bitcoin_address(encoding.hash160(script), address_prefix=address_prefix)
def txs_in_addresses (self, proxy):
rv = set()
for e in self.unsigned_txs_out:
rv.add(hash160_sec_to_bitcoin_address(ProxyTxOut.address_h160_from_script(e.script), addrversion=proxy.addrversion))
return rv
def change_prefix(address, new_prefix):
return hash160_sec_to_bitcoin_address(Key.from_text(address).hash160(), address_prefix=new_prefix)
def raw_to_address(self, raw_address):
return hash160_sec_to_bitcoin_address(raw_address,
is_test=self.testnet)
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))
def _hash160_to_address(testnet, hash160):
prefix = b'\x6f' if testnet else b"\0"
return hash160_sec_to_bitcoin_address(hash160, address_prefix=prefix)
