def test_signature_hash(self):
compressed = False
exponent_2 = int(
"137f3276686959c82b454eea6eefc9ab1b9e45bd4636fb9320262e114e321da1",
16)
bitcoin_address_2 = public_pair_to_bitcoin_address(
exponent_2 * secp256k1_generator, compressed=compressed)
exponent = wif_to_secret_exponent(
"5JMys7YfK72cRVTrbwkq5paxU7vgkMypB55KyXEtN5uSnjV7K8Y")
public_key_sec = public_pair_to_sec(exponent * secp256k1_generator,
compressed=compressed)
the_coinbase_tx = Tx.coinbase_tx(public_key_sec, int(50 * 1e8),
COINBASE_BYTES_FROM_80971)
coins_from = [(the_coinbase_tx.hash(), 0, the_coinbase_tx.txs_out[0])]
coins_to = [(int(50 * 1e8), bitcoin_address_2)]
unsigned_coinbase_spend_tx = standard_tx(coins_from, coins_to)
tx_out_script_to_check = the_coinbase_tx.txs_out[0].script
idx = 0
actual_hash = unsigned_coinbase_spend_tx.signature_hash(
tx_out_script_to_check, idx, hash_type=SIGHASH_ALL)
self.assertEqual(
actual_hash,
29819170155392455064899446505816569230970401928540834591675173488544269166940
)
def add_sec_annotations(a1, data, address_prefix):
pair = sec_to_public_pair(data)
is_compressed = is_sec_compressed(data)
a1.append(
"SEC for %scompressed %s" %
("" if is_compressed else "un",
public_pair_to_bitcoin_address(
pair, compressed=is_compressed, 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 = 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 msg_verify(args, parser):
message_hash = get_message_hash(args)
try:
pair, is_compressed = pair_for_message(args.signature, msg_hash=message_hash, netcode=args.network)
except encoding.EncodingError:
pass
prefix = address_prefix_for_netcode(args.network)
ta = encoding.public_pair_to_bitcoin_address(pair, compressed=is_compressed, address_prefix=prefix)
if args.address:
if ta == args.address:
print("signature ok")
return 0
else:
print("bad signature, matches %s" % ta)
return 1
else:
print(ta)
def add_signature_annotations(annotations, signature_blob,
signature_for_hash_type_f, output_script):
sig_pair, sig_type = parse_signature_blob(signature_blob)
annotations.append("r: {0:#066x}".format(sig_pair[0]))
annotations.append("s: {0:#066x}".format(sig_pair[1]))
sig_hash = signature_for_hash_type_f(sig_type, output_script)
annotations.append("z: {0:#066x}".format(sig_hash))
annotations.append("signature type %s" % sighash_type_to_string(sig_type))
addresses = []
pairs = possible_public_pairs_for_signature(generator_secp256k1, sig_hash,
sig_pair)
for pair in pairs:
for comp in (True, False):
address = public_pair_to_bitcoin_address(pair,
compressed=comp,
address_prefix=b'\0')
addresses.append(address)
annotations.append(" sig for %s" % " ".join(addresses))
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))
import hashlib
import struct
import unittest
from pycoin_grs.ecdsa.secp256k1 import secp256k1_generator
from pycoin_grs.encoding import public_pair_to_bitcoin_address, secret_exponent_to_wif
from pycoin_grs.tx.exceptions import BadSpendableError
from pycoin_grs.tx.tx_utils import create_signed_tx
from pycoin_grs.tx.Spendable import Spendable
from pycoin_grs.ui import standard_tx_out_script
BITCOIN_ADDRESSES = [public_pair_to_bitcoin_address(i * secp256k1_generator) 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 test_build_spends(self):
# first, here is the tx database
TX_DB = {}
# create a coinbase Tx where we know the public & private key
exponent = wif_to_secret_exponent(
"5JMys7YfK72cRVTrbwkq5paxU7vgkMypB55KyXEtN5uSnjV7K8Y")
compressed = False
public_key_sec = public_pair_to_sec(exponent * secp256k1_generator,
compressed=compressed)
the_coinbase_tx = Tx.coinbase_tx(public_key_sec, int(50 * 1e8),
COINBASE_BYTES_FROM_80971)
TX_DB[the_coinbase_tx.hash()] = the_coinbase_tx
# now create a Tx that spends the coinbase
compressed = False
exponent_2 = int(
"137f3276686959c82b454eea6eefc9ab1b9e45bd4636fb9320262e114e321da1",
16)
bitcoin_address_2 = public_pair_to_bitcoin_address(
exponent_2 * secp256k1_generator, compressed=compressed)
self.assertEqual("12WivmEn8AUth6x6U8HuJuXHaJzDw3gHNZ",
bitcoin_address_2)
coins_from = [(the_coinbase_tx.hash(), 0, the_coinbase_tx.txs_out[0])]
coins_to = [(int(50 * 1e8), bitcoin_address_2)]
unsigned_coinbase_spend_tx = standard_tx(coins_from, coins_to)
solver = build_hash160_lookup([exponent])
coinbase_spend_tx = unsigned_coinbase_spend_tx.sign(solver)
# now check that it validates
self.assertEqual(coinbase_spend_tx.bad_signature_count(), 0)
TX_DB[coinbase_spend_tx.hash()] = coinbase_spend_tx
# now try to respend from priv_key_2 to priv_key_3
compressed = True
exponent_3 = int(
"f8d39b8ecd0e1b6fee5a340519f239097569d7a403a50bb14fb2f04eff8db0ff",
16)
bitcoin_address_3 = public_pair_to_bitcoin_address(
exponent_3 * secp256k1_generator, compressed=compressed)
self.assertEqual("13zzEHPCH2WUZJzANymow3ZrxcZ8iFBrY5",
bitcoin_address_3)
coins_from = [(coinbase_spend_tx.hash(), 0,
coinbase_spend_tx.txs_out[0])]
unsigned_spend_tx = standard_tx(coins_from,
[(int(50 * 1e8), bitcoin_address_3)])
solver.update(build_hash160_lookup([exponent_2]))
spend_tx = unsigned_spend_tx.sign(solver)
# now check that it validates
self.assertEqual(spend_tx.bad_signature_count(), 0)
