def _create_script_signature(self, secret_exponent,
signature_for_hash_type_f, signature_type,
script):
sign_value = signature_for_hash_type_f(signature_type, script)
order = secp256k1_generator.order()
r, s = secp256k1_generator.sign(secret_exponent, sign_value)
if s + s > order:
s = order - s
return der.sigencode_der(r, s) + int2byte(signature_type)
def test_inverse_mod(self):
prime = secp256k1_generator.curve().p()
order = secp256k1_generator.order()
for v in range(70):
n = int(float("1e%d" % v))
i = secp256k1_generator.inverse_mod(n, prime)
assert n * i % prime == 1
i = secp256k1_generator.inverse_mod(n, order)
assert n * i % order == 1
def __init__(self, secret_exponent=None, public_pair=None, hash160=None,
prefer_uncompressed=None, is_compressed=None, is_pay_to_script=False, netcode=None):
"""
secret_exponent:
a long representing the secret exponent
public_pair:
a tuple of long integers on the ecdsa curve
hash160:
a hash160 value corresponding to a bitcoin address
Include at most one of secret_exponent, public_pair or hash160.
prefer_uncompressed:
whether or not to produce text outputs as compressed or uncompressed.
is_pay_to_script:
whether or not this key is for a pay-to-script style transaction
netcode:
the code for the network (as defined in pycoin.networks)
Include at most one of secret_exponent, public_pair or hash160.
prefer_uncompressed, is_compressed (booleans) are optional.
"""
if is_compressed is None:
is_compressed = False if hash160 else True
if netcode is None:
netcode = get_current_netcode()
if [secret_exponent, public_pair, hash160].count(None) != 2:
raise ValueError("exactly one of secret_exponent, public_pair, hash160 must be passed.")
if prefer_uncompressed is None:
prefer_uncompressed = not is_compressed
self._prefer_uncompressed = prefer_uncompressed
self._secret_exponent = secret_exponent
self._public_pair = public_pair
self._hash160_uncompressed = None
self._hash160_compressed = None
if hash160:
if is_compressed:
self._hash160_compressed = hash160
else:
self._hash160_uncompressed = hash160
self._netcode = netcode
if self._public_pair is None and self._secret_exponent is not None:
if self._secret_exponent < 1 \
or self._secret_exponent >= secp256k1_generator.order():
raise InvalidSecretExponentError()
public_pair = self._secret_exponent * secp256k1_generator
self._public_pair = public_pair
if self._public_pair is not None \
and (None in self._public_pair or
not secp256k1_generator.contains_point(*self._public_pair)):
raise InvalidPublicPairError()
def sigmake(a_key, a_hash_for_sig, a_sig_type=SIGHASH_ALL):
"""
Signs a_hash_for_sig with a_key and returns a DER-encoded signature
with a_sig_type appended.
"""
order = secp256k1_generator.order()
r, s = secp256k1_generator.sign(a_key.secret_exponent(), a_hash_for_sig)
if s + s > order:
s = order - s
return sigencode_der(r, s) + int2byte(a_sig_type)
def do_test(secret_exponent, val_list):
public_point = secret_exponent * secp256k1_generator
for v in val_list:
signature = secp256k1_generator.sign(secret_exponent, v)
r = secp256k1_generator.verify(public_point, v, signature)
assert r is True
r = secp256k1_generator.verify(
public_point, v,
(signature[0], secp256k1_generator.order() - signature[1]))
assert r is True
signature = signature[0], signature[1] + 1
r = secp256k1_generator.verify(public_point, v, signature)
assert r is False
def test_multiply(self):
g2 = secp256k1_generator * 2
g2p = g2 * 1
self.assertEqual(g2p, g2)
g4 = g2 * 2
self.assertEqual(g4, secp256k1_generator * 4)
g8 = g2 * 4
self.assertEqual(g8, secp256k1_generator * 8)
g24 = g8 * 3
self.assertEqual(g24, secp256k1_generator * 24)
g_big = g2 * (71**41)
self.assertEqual(
g_big,
secp256k1_generator * ((2 * 71**41) % secp256k1_generator.order()))
def test_key_limits(self):
nc = 'BTC'
cc = b'000102030405060708090a0b0c0d0e0f'
order = secp256k1_generator.order()
for k in -1, 0, order, order + 1:
self.assertRaises(InvalidSecretExponentError,
Key,
secret_exponent=k)
self.assertRaises(InvalidSecretExponentError,
BIP32Node,
nc,
cc,
secret_exponent=k)
for i in range(1, 512):
Key(secret_exponent=i)
BIP32Node(nc, cc, secret_exponent=i)
def parse_as_secret_exponent(s):
v = parse_as_number(s)
if v and 0 < v < secp256k1_generator.order():
return v
def generate_default_placeholder_signature():
order = secp256k1_generator.order()
r, s = order - 1, order // 2
return der.sigencode_der(r, s) + int2byte(1)
import hashlib
import itertools
from pycoinzpub.ecdsa.secp256k1 import secp256k1_generator
from pycoinzpub.encoding import double_sha256, from_bytes_32, to_bytes_32
from pycoinzpub.key import Key
from pycoinzpub.serialize import b2h
ORDER = secp256k1_generator.order()
def initial_key_to_master_key(initial_key):
"""
initial_key:
a hex string of length 32
"""
b = initial_key.encode("utf8")
orig_input = b
for i in range(100000):
b = hashlib.sha256(b + orig_input).digest()
return from_bytes_32(b)
class ElectrumWallet(Key):
def __init__(self,
initial_key=None,
master_private_key=None,
master_public_key=None,
netcode='BTC'):
if [initial_key, master_private_key, master_public_key
].count(None) != 2: