def serialize(self, jsontx):
"""Create a transaction from json inputs.
Inputs must have a redeemPubkey.
Outputs must be a list of {'address':address, 'value':satoshi_amount}.
"""
keypairs = {}
inputs = jsontx.get('inputs')
outputs = jsontx.get('outputs')
locktime = jsontx.get('locktime', 0)
for txin in inputs:
if txin.get('output'):
prevout_hash, prevout_n = txin['output'].split(':')
txin['prevout_n'] = int(prevout_n)
txin['prevout_hash'] = prevout_hash
sec = txin.get('privkey')
if sec:
privkey = PrivateKey.from_text(sec)
txin_type, privkey, compressed = ('p2pkh', privkey.to_bytes(),
privkey.is_compressed())
pubkey = privkey.public_key.to_hex()
keypairs[pubkey] = privkey, compressed
txin['type'] = txin_type
txin['x_pubkeys'] = [pubkey]
txin['signatures'] = [None]
txin['num_sig'] = 1
outputs = [(TYPE_ADDRESS, Address.from_string(x['address']),
int(x['value'])) for x in outputs]
tx = Transaction.from_io(inputs, outputs, locktime=locktime)
tx.sign(keypairs)
return tx.as_dict()
def test_import_privkey(self, WIF, pk_string):
enc_prvkey_text = pw_encode(WIF, "password")
public_key = PrivateKey.from_text(WIF).public_key
d = Imported_KeyStore({})
d.import_private_key(1, public_key, enc_prvkey_text)
assert d.get_public_key_for_id(1) == public_key
assert WIF == d.export_private_key(public_key, "password")
def test_public_key_from_private_key(self):
for priv_details in self.priv_pub_addr:
privkey = PrivateKey.from_text(priv_details['priv'])
result = privkey.public_key.to_hex()
self.assertEqual(priv_details['pub'], result)
self.assertEqual(priv_details['txin_type'], 'p2pkh')
self.assertEqual(priv_details['compressed'], privkey.is_compressed())
def signtransaction(self, tx, privkey=None, password=None):
"""Sign a transaction. The wallet keys will be used unless a private key is provided."""
tx = Transaction.from_hex(tx)
if privkey:
privkey2 = PrivateKey.from_text(privkey)
txin_type, privkey2, compressed = ('p2pkh', privkey2.to_bytes(),
privkey2.is_compressed())
h160 = hash_160(privkey2.public_key.to_bytes())
x_pubkey = 'fd' + bh2u(b'\x00' + h160)
tx.sign({x_pubkey: (privkey2, compressed)})
else:
self.wallet.sign_transaction(tx, password)
return tx.as_dict()
def test_decrypt_message(self):
password = '******'
message = b'BitcoinSV'
prvkey_text = "5HueCGU8rMjxEXxiPuD5BDku4MkFqeZyd4dZ1jvhTVqvbTLvyTJ"
enc_prvkey_text = pw_encode(prvkey_text, password)
public_key = PrivateKey.from_text(prvkey_text).public_key
d = Imported_KeyStore({})
d.import_private_key(1, public_key, enc_prvkey_text)
enc_msg = ('QklFMQNkonLnVmRMF3dl+P0rHSbM4lvDPmnE2CFcD+98gGsOe6qtKtmVbCg4'
'9bxmT6vfmzl7udrvT81wH1Ri7wZItndtLiNHii6FBNVzoSV/1ZqN3w==')
decrypted_message = d.decrypt_message(public_key, enc_msg, password)
assert decrypted_message == message
def test_sign_message(self):
password = '******'
message = 'BitcoinSV'
prvkey_text = "5HueCGU8rMjxEXxiPuD5BDku4MkFqeZyd4dZ1jvhTVqvbTLvyTJ"
enc_prvkey_text = pw_encode(prvkey_text, password)
public_key = PrivateKey.from_text(prvkey_text).public_key
d = Imported_KeyStore({})
d.import_private_key(1, public_key, enc_prvkey_text)
msg_sig = d.sign_message(public_key, message, password)
assert msg_sig.hex() == (
'1c26a18cb236e54bbe7e3db56639ef5cbefcf5a2e28850cdd304970832f84031'
'fc073bed1a151f0510e5558a22d23f16ed8032a1b74ffcac05227c053e1a1d8af5'
)
def to_tx_input(txin):
prev_hash, prev_idx = txin['output'].split(':')
x_pubkeys = []
value = txin.get('value')
sec = txin.get('privkey')
threshold = 1
if sec:
privkey = PrivateKey.from_text(sec)
privkey, compressed = privkey.to_bytes(), privkey.is_compressed()
x_pubkey = XPublicKey(privkey.public_key.to_hex())
keypairs[x_pubkey] = privkey, compressed
x_pubkeys = [x_pubkey]
return XTxInput(
prev_hash=hex_str_to_hash(prev_hash),
prev_idx=int(prev_idx),
script_sig=Script(),
sequence=0xffffffff,
value=value,
x_pubkeys=x_pubkeys,
address=None,
threshold=threshold,
signatures=[NO_SIGNATURE] * len(x_pubkeys),
)
def get_private_key(self, pubkey: PublicKey,
password: str) -> Tuple[bytes, bool]:
'''Returns a (32 byte privkey, is_compressed) pair.'''
privkey_text = self.export_private_key(pubkey, password)
privkey = PrivateKey.from_text(privkey_text)
return privkey.to_bytes(), privkey.is_compressed()
def _public_key_from_private_key_text(text):
return PrivateKey.from_text(text).public_key
def is_private_key(text: str) -> bool:
try:
PrivateKey.from_text(text)
return True
except ValueError:
return False
