def test_segwit_create_tx(self):
from pycoin_grs.tx.tx_utils import create_tx, sign_tx
from pycoin_grs.tx.Spendable import Spendable
from pycoin_grs.tx.pay_to.ScriptPayToAddress import ScriptPayToAddress
from pycoin_grs.tx.pay_to.ScriptPayToAddressWit import ScriptPayToAddressWit
from pycoin_grs.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_against_myself():
"""
Test code that verifies against ourselves only. Useful but not so great.
"""
from pycoin_grs.contrib.msg_signing import (
parse_signed_message, sign_message, verify_message)
from pycoin_grs.encoding import bitcoin_address_to_hash160_sec_with_prefix
from pycoin_grs.encoding import wif_to_tuple_of_secret_exponent_compressed
for wif, right_addr in [
('L4gXBvYrXHo59HLeyem94D9yLpRkURCHmCwQtPuWW9m6o1X8p8sp',
'1LsPb3D1o1Z7CzEt1kv5QVxErfqzXxaZXv'),
('5KYZdUEo39z3FPrtuX2QbbwGnNP5zTd7yyr2SC1j299sBCnWjss',
'1HZwkjkeaoZfTSaJxDw6aKkxp45agDiEzN'),
]:
se, comp = wif_to_tuple_of_secret_exponent_compressed(wif)
k = Key(secret_exponent=se, is_compressed=comp)
assert k.address() == right_addr
vk = Key(public_pair=k.public_pair(), is_compressed=comp)
assert vk.address() == right_addr
h160, pubpre = bitcoin_address_to_hash160_sec_with_prefix(right_addr)
vk2 = Key(hash160=h160)
assert vk2.address() == right_addr
for i in range(1, 30, 10):
msg = 'test message %s' % ('A'*i)
sig = sign_message(k, msg, verbose=1)
assert right_addr in sig
# check parsing works
m, a, s = parse_signed_message(sig)
assert m == msg, m
assert a == right_addr, a
sig2 = sign_message(k, msg, verbose=0)
assert sig2 in sig, (sig, sig2)
assert s == sig2, s
ok = verify_message(k, sig2, msg)
assert ok
ok = verify_message(k, sig2.encode('ascii'), msg)
assert ok
def test_script_type_pay_to_public_pair(self):
for se in range(1, 100):
key = Key(secret_exponent=se)
for b in [True, False]:
st = ScriptPayToPublicKey.from_key(key, use_uncompressed=b)
addr = key.address(use_uncompressed=b)
self.assertEqual(st.address(), addr)
sc = st.script()
st = script_obj_from_script(sc)
self.assertEqual(st.address(), addr)
def test_script_type_pay_to_address(self):
for se in range(1, 100):
key = Key(secret_exponent=se)
for b in [True, False]:
addr = key.address(use_uncompressed=b)
st = script_obj_from_address(addr)
self.assertEqual(st.address(), addr)
sc = st.script()
st = script_obj_from_script(sc)
self.assertEqual(st.address(), addr)
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_solve_pay_to_public_pair(self):
for se in range(1, 10):
key = Key(secret_exponent=se)
for b in [True, False]:
addr = key.address(use_uncompressed=b)
st = ScriptPayToPublicKey.from_key(key, use_uncompressed=b)
self.assertEqual(st.address(), addr)
hl = build_hash160_lookup([se])
sv = 100
st.solve(hash160_lookup=hl,
signature_for_hash_type_f=const_f(sv),
signature_type=SIGHASH_ALL)
sc = st.script()
st = script_obj_from_script(sc)
self.assertEqual(st.address(), addr)
def _test_sighash_single(self, netcode):
k0 = Key(secret_exponent=PRIV_KEYS[0],
is_compressed=True,
netcode=netcode)
k1 = Key(secret_exponent=PRIV_KEYS[1],
is_compressed=True,
netcode=netcode)
k2 = Key(secret_exponent=PRIV_KEYS[2],
is_compressed=True,
netcode=netcode)
k3 = Key(secret_exponent=PRIV_KEYS[3],
is_compressed=True,
netcode=netcode)
k4 = Key(secret_exponent=PRIV_KEYS[4],
is_compressed=True,
netcode=netcode)
k5 = Key(secret_exponent=PRIV_KEYS[5],
is_compressed=True,
netcode=netcode)
# Fake a coinbase transaction
coinbase_tx = Tx.coinbase_tx(k0.sec(), 500000000)
coinbase_tx.txs_out.append(
TxOut(1000000000,
pycoin_grs_compile('%s OP_CHECKSIG' % b2h(k1.sec()))))
coinbase_tx.txs_out.append(
TxOut(1000000000,
pycoin_grs_compile('%s OP_CHECKSIG' % b2h(k2.sec()))))
self.assertEqual(
'2acbe1006f7168bad538b477f7844e53de3a31ffddfcfc4c6625276dd714155a',
b2h_rev(coinbase_tx.hash()))
# Make the test transaction
txs_in = [
TxIn(coinbase_tx.hash(), 0),
TxIn(coinbase_tx.hash(), 1),
TxIn(coinbase_tx.hash(), 2),
]
txs_out = [
TxOut(900000000, standard_tx_out_script(k3.address())),
TxOut(800000000, standard_tx_out_script(k4.address())),
TxOut(800000000, standard_tx_out_script(k5.address())),
]
tx = Tx(1, txs_in, txs_out)
tx.set_unspents(coinbase_tx.txs_out)
self.assertEqual(
'791b98ef0a3ac87584fe273bc65abd89821569fd7c83538ac0625a8ca85ba587',
b2h_rev(tx.hash()))
sig_type = SIGHASH_SINGLE
sig_hash = tx.signature_hash(coinbase_tx.txs_out[0].script, 0,
sig_type)
self.assertEqual(
'cc52d785a3b4133504d1af9e60cd71ca422609cb41df3a08bbb466b2a98a885e',
b2h(to_bytes_32(sig_hash)))
sig = sigmake(k0, sig_hash, sig_type)
self.assertTrue(sigcheck(k0, sig_hash, sig[:-1]))
tx.txs_in[0].script = pycoin_grs_compile(b2h(sig))
self.assertTrue(tx.is_signature_ok(0))
sig_hash = tx.signature_hash(coinbase_tx.txs_out[1].script, 1,
sig_type)
self.assertEqual(
'93bb883d70fccfba9b8aa2028567aca8357937c65af7f6f5ccc6993fd7735fb7',
b2h(to_bytes_32(sig_hash)))
sig = sigmake(k1, sig_hash, sig_type)
self.assertTrue(sigcheck(k1, sig_hash, sig[:-1]))
tx.txs_in[1].script = pycoin_grs_compile(b2h(sig))
self.assertTrue(tx.is_signature_ok(1))
sig_hash = tx.signature_hash(coinbase_tx.txs_out[2].script, 2,
sig_type)
self.assertEqual(
'53ef7f67c3541bffcf4e0d06c003c6014e2aa1fb38ff33240b3e1c1f3f8e2a35',
b2h(to_bytes_32(sig_hash)))
sig = sigmake(k2, sig_hash, sig_type)
self.assertTrue(sigcheck(k2, sig_hash, sig[:-1]))
tx.txs_in[2].script = pycoin_grs_compile(b2h(sig))
self.assertTrue(tx.is_signature_ok(2))
sig_type = SIGHASH_SINGLE | SIGHASH_ANYONECANPAY
sig_hash = tx.signature_hash(coinbase_tx.txs_out[0].script, 0,
sig_type)
self.assertEqual(
'2003393d246a7f136692ce7ab819c6eadc54ffea38eb4377ac75d7d461144e75',
b2h(to_bytes_32(sig_hash)))
sig = sigmake(k0, sig_hash, sig_type)
self.assertTrue(sigcheck(k0, sig_hash, sig[:-1]))
tx.txs_in[0].script = pycoin_grs_compile(b2h(sig))
self.assertTrue(tx.is_signature_ok(0))
sig_hash = tx.signature_hash(coinbase_tx.txs_out[1].script, 1,
sig_type)
self.assertEqual(
'e3f469ac88e9f35e8eff0bd8ad4ad3bf899c80eb7645947d60860de4a08a35df',
b2h(to_bytes_32(sig_hash)))
sig = sigmake(k1, sig_hash, sig_type)
self.assertTrue(sigcheck(k1, sig_hash, sig[:-1]))
tx.txs_in[1].script = pycoin_grs_compile(b2h(sig))
self.assertTrue(tx.is_signature_ok(1))
sig_hash = tx.signature_hash(coinbase_tx.txs_out[2].script, 2,
sig_type)
self.assertEqual(
'bacd7c3ab79cad71807312677c1788ad9565bf3c00ab9a153d206494fb8b7e6a',
b2h(to_bytes_32(sig_hash)))
sig = sigmake(k2, sig_hash, sig_type)
self.assertTrue(sigcheck(k2, sig_hash, sig[:-1]))
tx.txs_in[2].script = pycoin_grs_compile(b2h(sig))
self.assertTrue(tx.is_signature_ok(2))
