def test_segwit_create_tx(self):
from pycoin.tx.tx_utils import create_tx, sign_tx
from pycoin.tx.Spendable import Spendable
from pycoin.tx.pay_to.ScriptPayToAddress import ScriptPayToAddress
from pycoin.tx.pay_to.ScriptPayToAddressWit import ScriptPayToAddressWit
from pycoin.tx.pay_to.ScriptPayToScriptWit import ScriptPayToScriptWit
from pycoin.ui import address_for_pay_to_script_wit, script_obj_from_address
key1 = Key(1)
coin_value = 5000000
script = ScriptPayToAddressWit(b'\0', key1.hash160()).script()
tx_hash = b'\ee' * 32
tx_out_index = 0
spendable = Spendable(coin_value, script, tx_hash, tx_out_index)
key2 = Key(2)
tx = create_tx([spendable], [(key2.address(), coin_value)])
self.check_unsigned(tx)
sign_tx(tx, [key1.wif()])
self.check_signed(tx)
self.assertEqual(len(tx.txs_in[0].witness), 2)
s1 = ScriptPayToAddress(key1.hash160()).script()
address = address_for_pay_to_script_wit(s1)
spendable.script = script_obj_from_address(address).script()
tx = create_tx([spendable], [(key2.address(), coin_value)])
self.check_unsigned(tx)
sign_tx(tx, [key1.wif()], p2sh_lookup=build_p2sh_lookup([s1]))
self.check_signed(tx)
def test_segwit_create_tx(self):
from pycoin.tx.tx_utils import create_tx, sign_tx
from pycoin.tx.Spendable import Spendable
from pycoin.tx.pay_to.ScriptPayToAddress import ScriptPayToAddress
from pycoin.tx.pay_to.ScriptPayToAddressWit import ScriptPayToAddressWit
from pycoin.tx.pay_to.ScriptPayToScriptWit import ScriptPayToScriptWit
from pycoin.ui import address_for_pay_to_script_wit, script_obj_from_address
key1 = Key(1)
coin_value = 5000000
script = ScriptPayToAddressWit(b'\0', key1.hash160()).script()
tx_hash = b'\ee' * 32
tx_out_index = 0
spendable = Spendable(coin_value, script, tx_hash, tx_out_index)
key2 = Key(2)
tx = create_tx([spendable], [(key2.address(), coin_value)])
self.check_unsigned(tx)
sign_tx(tx, [key1.wif()])
self.check_signed(tx)
self.assertEqual(len(tx.txs_in[0].witness), 2)
s1 = ScriptPayToAddress(key1.hash160()).script()
address = address_for_pay_to_script_wit(s1)
spendable.script = script_obj_from_address(address).script()
tx = create_tx([spendable], [(key2.address(), coin_value)])
self.check_unsigned(tx)
sign_tx(tx, [key1.wif()], p2sh_lookup=build_p2sh_lookup([s1]))
self.check_signed(tx)
def test_is_wif_valid(self):
WIFS = [
"KwDiBf89QgGbjEhKnhXJuH7LrciVrZi3qYjgd9M7rFU73sVHnoWn",
"5HpHagT65TZzG1PH3CSu63k8DbpvD8s5ip4nEB3kEsreAnchuDf",
"KwDiBf89QgGbjEhKnhXJuH7LrciVrZi3qYjgd9M7rFU74NMTptX4",
"5HpHagT65TZzG1PH3CSu63k8DbpvD8s5ip4nEB3kEsreAvUcVfH"
]
for wif in WIFS:
self.assertEqual(is_wif_valid(wif), "BTC")
a = wif[:-1] + chr(ord(wif[-1]) + 1)
self.assertEqual(is_wif_valid(a), None)
NETWORK_NAMES = network_codes()
for netcode in NETWORK_NAMES:
for se in range(1, 10):
key = Key(secret_exponent=se, netcode=netcode)
for tv in [True, False]:
wif = key.wif(use_uncompressed=tv)
self.assertEqual(
is_wif_valid(wif, allowable_netcodes=[netcode]),
netcode)
a = wif[:-1] + chr(ord(wif[-1]) + 1)
self.assertEqual(
is_wif_valid(a, allowable_netcodes=[netcode]), None)
def gen_key_pair_as_wif():
key, pri_hex = _gen_pri_key()
my_key = Key(secret_exponent=key,
prefer_uncompressed=False,
netcode=NET_CODE)
return my_key.wif(), my_key.address()
def test_repr(self):
key = Key(secret_exponent=273, netcode='XTN')
address = key.address()
pub_k = Key.from_text(address)
self.assertEqual(repr(pub_k), '<mhDVBkZBWLtJkpbszdjZRkH1o5RZxMwxca>')
wif = key.wif()
priv_k = Key.from_text(wif)
self.assertEqual(repr(priv_k), 'private_for <0264e1b1969f9102977691a40431b0b672055dcf31163897d996434420e6c95dc9>')
def test_repr(self):
key = Key(secret_exponent=273, netcode='XTN')
address = key.address()
pub_k = Key.from_text(address)
self.assertEqual(repr(pub_k), '<mhDVBkZBWLtJkpbszdjZRkH1o5RZxMwxca>')
wif = key.wif()
priv_k = Key.from_text(wif)
self.assertEqual(
repr(priv_k),
'private_for <0264e1b1969f9102977691a40431b0b672055dcf31163897d996434420e6c95dc9>'
)
def gen_2of3_multisig_key_pair():
key_pairs = []
for i in range(0, 3):
key, pri_hex = _gen_pri_key()
my_key = Key(secret_exponent=key,
prefer_uncompressed=False,
netcode=NET_CODE)
# return wif or hex format, use your own strategy
key_pairs.append((my_key.wif(), my_key.sec_as_hex()))
return get_multisig_address(
2, [binascii.unhexlify(key[1]) for key in key_pairs]), key_pairs
def test_repr(self):
from pycoin.key import Key
netcode = 'XTN'
key = Key(secret_exponent=273, netcode=netcode)
wallet = BIP32Node.from_master_secret(bytes(key.wif().encode('ascii')), netcode)
address = wallet.address()
pub_k = wallet.from_text(address)
self.assertEqual(repr(pub_k), '<myb5gZNXePNf2E2ksrjnHRFCwyuvt7oEay>')
wif = wallet.wif()
priv_k = wallet.from_text(wif)
self.assertEqual(repr(priv_k), 'private_for <03ad094b1dc9fdce5d3648ca359b4e210a89d049532fdd39d9ccdd8ca393ac82f4>')
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 test_is_wif_valid(self):
WIFS = ["KwDiBf89QgGbjEhKnhXJuH7LrciVrZi3qYjgd9M7rFU73sVHnoWn",
"5HpHagT65TZzG1PH3CSu63k8DbpvD8s5ip4nEB3kEsreAnchuDf",
"KwDiBf89QgGbjEhKnhXJuH7LrciVrZi3qYjgd9M7rFU74NMTptX4",
"5HpHagT65TZzG1PH3CSu63k8DbpvD8s5ip4nEB3kEsreAvUcVfH"]
for wif in WIFS:
self.assertEqual(is_wif_valid(wif), "BTC")
a = wif[:-1] + chr(ord(wif[-1])+1)
self.assertEqual(is_wif_valid(a), None)
for netcode in NETWORK_NAMES:
for se in range(1, 10):
key = Key(secret_exponent=se, netcode=netcode)
for tv in [True, False]:
wif = key.wif(use_uncompressed=tv)
self.assertEqual(is_wif_valid(wif, allowable_netcodes=[netcode]), netcode)
a = wif[:-1] + chr(ord(wif[-1])+1)
self.assertEqual(is_wif_valid(a, allowable_netcodes=[netcode]), None)
def generatePrivateKey(seed, net="XTN"):
"""
Generating a private key from any hexadecimal seed and net
Args:
-----
seed: The seed to be used to generate the private key.
net: The network to be used.
Returns:
--------
The private key to be used.
"""
# Generating the hexadecimal representation of the brainwallet
key_bytes = hexlify(seed)
# '68656c6c6f' for "hello"
priv = Key(secret_exponent=int(codecs.encode(key_bytes, "hex"), 16),
netcode=net)
# Representation of the wallet
print("\tSeed: " + seed)
print("\tAddress: " + priv.address())
print("\tWIF: " + priv.wif())
return priv
def secret_to_address(secret_exponent):
k = Key(secret_exponent=secret_exponent)
addr = k.address(use_uncompressed=True)
caddr = k.address()
wif = k.wif(use_uncompressed=True)
return secret_exponent, wif, addr, caddr
print('Your Bitcoin address is...', address)
print('Your --privkey-bytes', hexlify(key_bytes).decode())
try:
spendables = spendables_for_address(address, None)
print('Spending', spendables)
except HTTPError as e:
print(
'Blockchain throws a 500 error if there are no spendables. Try sending some coins to',
address, 'and try again. Remeber to copy privkey-bytes.')
sys.exit()
tx = create_tx(spendables, [args.send_all_to])
print('TX created:', repr(tx))
sign_tx(tx, [private_key.wif(False), private_key.wif(True)])
print('Final TX:', tx)
# print('TX Send Attempt:', send_tx(tx))
'''
tx_in = TxIn("<utxo hash in binary here>", <utxo position, usually between 0 and 5>)
script = standard_tx_out_script(address)
tx_out = TxOut(<btc amount to send - fee>, script)
tx = Tx(1, [tx_in], [tx_out])
lookup = <this part you have to figure out>
tx.sign(lookup)
print tx.as_hex()
def privateKeyToWif(key_hex):
def register_page(request, refererUUID):
getBtcPrice()
price = sysvar.objects.get(pk=1)
btcPrice = price.btcPrice
counter = price.counter
email_taken = False
username_taken = False
if request.user.is_authenticated():
return render(request, 'home.html')
registration_form = RegistrationForm()
if request.method == 'POST':
form = RegistrationForm(request.POST)
if form.is_valid():
datas = {}
if User.objects.filter(
username=form.cleaned_data['username']).exists():
username_taken = True
return render(
request, 'register_page.html', {
'form': registration_form,
'username_taken': username_taken,
'btcPrice': btcPrice
})
elif User.objects.filter(
email=form.cleaned_data['email']).exists():
email_taken = True
return render(
request, 'register_page.html', {
'form': registration_form,
'email_taken': email_taken,
'btcPrice': btcPrice
})
datas['username'] = form.cleaned_data['username']
datas['email'] = form.cleaned_data['email']
datas['password1'] = form.cleaned_data['password1']
datas['referer'] = refererUUID
#We will generate a random activation key
s = 'xprv9s21ZrQH143K2Lap6SnULZfdEi4ivcbottMVoY7MaupCQhVLfARkygyW9N7PKsBSPd2gTQXZr1R4iqkLCQ3TUxvs9NvwYRScCVGV8Aos7ad'
mykey = Key.from_text(s)
mysub = mykey.subkey(counter)
address = Key.address(mysub)
wif = Key.wif(mysub)
datas['deposit_add'] = address
datas['wif'] = wif
price.counter = price.counter + 1
price.save()
salt = hashlib.sha1(str(
random.random()).encode('utf-8')).hexdigest()[:5]
usernamesalt = datas['email']
if isinstance(usernamesalt, str):
usernamesalt = str.encode(usernamesalt)
if isinstance(salt, str):
salt = str.encode(salt)
print(salt)
print(usernamesalt)
datas['activation_key'] = hashlib.sha1(salt +
usernamesalt).hexdigest()
datas[
'email_path'] = "/home/connell-gough/django/bl4btc/btc/static/ActivationEmail.txt"
datas['email_subject'] = "activate your account"
form.sendEmail(datas) #Send validation email
form.save(datas) #Save the user and his profile
request.session['registered'] = True #For display purposes
return render(request, 'register_page.html', {
'email_sent': True,
'btcPrice': btcPrice
})
else:
registration_form = form #Display form with error messages (incorrect fields, etc)
return render(
request, 'register_page.html', {
'form': registration_form,
'btcPrice': btcPrice,
'refererUUID': refererUUID
})
def secret_to_address(secret_exponent):
k = Key(secret_exponent=secret_exponent)
addr = k.address(use_uncompressed=True)
caddr = k.address()
wif = k.wif(use_uncompressed=True)
return secret_exponent, wif, addr, caddr
from pycoin.key import Key from pycoin.serialize import h2b from pycoin.tx import Tx, TxIn, TxOut, SIGHASH_ALL, tx_utils from pycoin.tx.TxOut import standard_tx_out_script from pycoin.tx.pay_to import ScriptMultisig, ScriptPayToPublicKey from pycoin.tx.pay_to import address_for_pay_to_script, build_hash160_lookup, build_p2sh_lookup from pycoin.tx.pay_to import script_obj_from_address, script_obj_from_script publicaddress = "mkR94WCqr4gpZauH8ieTLTG6jkZ2uBB6SA" wif = "cUDx8gXXBZRePmm46LSZetbWqNwXBmm3WQziGVykAgL8NJKMRjQR" key = Key.from_text(publicaddress) key = Key(secret_exponent=1) print key.address() print key.wif() print key.secret_exponent()
from pycoin.key import Key, BIP32Node
import argparse
parser = argparse.ArgumentParser()
parser.add_argument("--netcode",
type=str,
required=True,
help='netcode: BTC/LTC/XTN/...')
parser.add_argument("--target", type=str, required=True, help='to address')
args = parser.parse_args()
to_address = args.target
private_key = 'YOUR PRIVATE KEY'
the_key = Key(secret_exponent=int(private_key, 16))
master_key = BIP32Node.BIP32Node.from_master_secret(
bytes(the_key.wif().encode('ascii')), args.netcode)
from_address = master_key.address()
# that's work for insight
# TODO: 设计通用utxo
def get_speendable(address):
URL = "%s%saddr/%s/utxo" % ('https://test-insight.bitpay.com', '/api/',
from_address)
utxos = json.loads(urlopen(URL).read().decode("utf8"))
utxo = utxos[0]
return Spendable(utxo['amount'], h2b(utxo.get("scriptPubKey")),
h2b_rev(utxo.get("txid")), utxo.get("vout"))
privkey_hex = b2h(encoding.to_bytes_32(my_key.secret_exponent()))
assert(len(privkey_hex) == 64)
print("\npycoin.key.Key example - ", my_netcode)
#print("Private Key (dec): ", eval('0x' + privkey_hex))
print("Private Key (dec): ", int(privkey_hex, 16))
print("Private Key (hex): ", privkey_hex)
privkey_bytes = unhexlify(privkey_hex)
# use CBitcoinSecret to compress private key
btc_secret = CBitcoinSecret.from_secret_bytes(privkey_bytes, True)
print(" compressed: ", hexlify(btc_secret.to_bytes()))
assert(btc_secret.is_compressed == True)
assert(bitcoin.core.b2x(btc_secret.to_bytes()) == (privkey_hex + '01'))
print("Private Key WIF: ", my_key.wif())
print(" uncompressed: ", my_key.wif(use_uncompressed=True))
print("Privkey hashed base58: ", encoding.b2a_hashed_base58(privkey_bytes))
print()
## Public key and address
public_key = my_key.public_pair()
(public_key_x, public_key_y) = public_key
print("Public Key Pair: ", public_key)
print(" x as hex: ", hex(public_key[0]))
print(" y as hex: ", hex(public_key[1]))
#compressed_indicator_1 = '02' if (public_key_y % 2) == 0 else '03'
def main():
parser = argparse.ArgumentParser(
description='ECkey2coin.py by [email protected] for UTXO based Certificates UTXOC.',
epilog='Known networks codes:\n ' \
+ ', '.join(['%s (%s)'%(i, full_network_name_for_netcode(i)) for i in NETWORK_NAMES])
)
parser.add_argument('-k', '--key', required=False, type=argparse.FileType('r'), help='The EC private key in PEM format')
parser.add_argument('-q', '--qrfilename', required=False, help='QR code output filename')
parser.add_argument('-n', "--network", help='specify network (default: BTC = Bitcoin)',
default='BTC', choices=NETWORK_NAMES)
args = parser.parse_args()
network = args.network
inputprivatekey = ''
if args.key:
keyfile = args.key
while True:
line = keyfile.readline().strip()
if not line: break
inputprivatekey += line + '\n'
print 'Loaded EC Key from %s' % keyfile
else:
print ('Please enter EC KEY in pem format:')
inputprivatekey = ''
while True:
line = raw_input().strip()
if not line: break
inputprivatekey += line + '\n'
if not args.qrfilename:
qrfilename = raw_input("Please enter qrcode output filename: ")
else:
qrfilename = args.qrfilename
pkey = decoder.decode(read_pem(inputprivatekey), asn1Spec=ECPrivateKey())
print 'Key loaded'
if not isValidECKey(pkey[0]):
print "EC Key Supplied cannot be used"
exit
print "Key Validated OK"
inputkey = encoding.to_long(256, pycoin.encoding.byte_to_int, pkey[0][1].asOctets())[0]
if inputkey:
key = Key(secret_exponent=inputkey, netcode=network)
btcsecret = key.secret_exponent()
btcpublic = key.public_pair()
hash160_c = key.hash160(use_uncompressed=False)
hash160_u = key.hash160(use_uncompressed=True)
qrimg = qrcode.QRCode (
version=1,
error_correction=qrcode.constants.ERROR_CORRECT_L,
box_size=10,
border=4,
)
qrimg.add_data(key.address(use_uncompressed=False))
qrimg.make(fit=True)
img = qrimg.make_image()
img.save(qrfilename)
print"----------------- BEGIN EC PRIVATE KEYS -----------------"
print "Secret: %d" % btcsecret
print "Secret hex: %x" % btcsecret
print "wif: %s" % key.wif(use_uncompressed=False)
print "----------------- END EC PRIVATE KEYS -----------------------------"
print "----------------- BEGIN PUBLIC KEY -----------------------------"
print "Public X: %d" % btcpublic[0]
print "Public Y: %d" % btcpublic[1]
print "hash160 uncompressed: %s" % b2h(hash160_u)
print "Sec: (uncompressed): %s" % b2h(key.sec(use_uncompressed=True))
print "%s address: %s (uncompressed)" % (key._netcode, key.address(use_uncompressed=True))
print "Public X (hex): %x" % btcpublic[0]
print "Public Y (hex): %x" % btcpublic[1]
print "Sec: %s" % b2h(key.sec(use_uncompressed=False))
print "hash160 compressed: %s" % b2h(hash160_c)
print "----------------- END PUBLIC KEYS -----------------------------"
print "------------------ BEGIN %s ADDRESSES -------------------------" % key._netcode
print "%s address: %s" % (key._netcode, key.address(use_uncompressed=False))
print "------------------ END %s ADDRESSES -------------------------" % key._netcode
