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 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 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 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 }
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 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))