def test_from_invalid_scriptPubKey(self):
"""CBitcoinAddress.from_scriptPubKey() with invalid scriptPubKeys"""
# We should raise a CBitcoinAddressError, not any other type of error
# Truncated P2SH
scriptPubKey = CScript(x('a91400000000000000000000000000000000000000'))
with self.assertRaises(CBitcoinAddressError):
CBitcoinAddress.from_scriptPubKey(scriptPubKey)
# Truncated P2PKH
scriptPubKey = CScript(x('76a91400000000000000000000000000000000000000'))
with self.assertRaises(CBitcoinAddressError):
CBitcoinAddress.from_scriptPubKey(scriptPubKey)
def test(self):
data = x(
'5586e3531b857c5a3d7af6d512ec84161f4531b66daf2ad72a6f647e4164c8ae')
k = CKey(data)
self.assertEqual(k, data)
expected_pub = x(
'0392aef1ad6db10a2da4aa9f9e874fa28d5423eaa29ee83aa9acec01cc812903df'
)
self.assertEqual(k.pub, expected_pub)
expected_uncompressed_pub = x(
'0492aef1ad6db10a2da4aa9f9e874fa28d5423eaa29ee83aa9acec01cc812903df4c9b555eb62f0bf6dc4406b271365768737733ec8af4024809348ea594eef1f3'
)
k = CKey(data, compressed=False)
self.assertEqual(k.pub, expected_uncompressed_pub)
def test_add_sub(self) -> None:
k1 = CKey(x('5586e3531b857c5a3d7af6d512ec84161f4531b66daf2ad72a6f647e4164c8ae'))
k2 = CKey(x('9e77dd4f6693461578e32e60e9c095023e1fc98ae3eaf0c53f645d53a5ead91e'))
k_sum = CKey.add(k1, k2)
pub_sum = CPubKey.add(k1.pub, k2.pub)
self.assertEqual(pub_sum, k_sum.pub)
if secp256k1_has_pubkey_negate:
k_diff = CKey.sub(k1, k2)
pub_diff = CPubKey.sub(k1.pub, k2.pub)
self.assertEqual(pub_diff, k_diff.pub)
self.assertEqual(k1, CKey.sub(k_sum, k2))
self.assertEqual(k2, CKey.sub(k_sum, k1))
self.assertEqual(k1, CKey.add(k_diff, k2))
self.assertEqual(k2.negated(), CKey.sub(k_diff, k1))
self.assertEqual(CKey.add(k2, k2), CKey.sub(k_sum, k_diff))
self.assertEqual(k1.pub, CPubKey.sub(pub_sum, k2.pub))
self.assertEqual(k2.pub, CPubKey.sub(pub_sum, k1.pub))
self.assertEqual(k1.pub, CPubKey.add(pub_diff, k2.pub))
self.assertEqual(k2.pub.negated(), CPubKey.sub(pub_diff, k1.pub))
self.assertEqual(CPubKey.add(k2.pub, k2.pub),
CPubKey.sub(pub_sum, pub_diff))
self.assertEqual(k1,
CKey.combine(k1, k2, k_sum,
k2.negated(), k_sum.negated()))
self.assertEqual(k1.pub,
CPubKey.combine(k1.pub, k2.pub, k_sum.pub,
k2.pub.negated(),
k_sum.pub.negated()))
self.assertEqual(CKey.combine(k_sum, k2, k1, k_diff),
CKey.combine(k1, k2, k_sum, k_diff))
self.assertEqual(CPubKey.combine(k_sum.pub, k2.pub, k1.pub,
k_diff.pub),
CPubKey.combine(k1.pub, k2.pub, k_sum.pub,
k_diff.pub))
with self.assertRaises(ValueError):
CKey.sub(k1, k1)
with self.assertRaises(ValueError):
CKey.combine(k1, k2, k1.negated(), k2.negated())
with self.assertRaises(ValueError):
CPubKey.sub(k1.pub, k1.pub)
with self.assertRaises(ValueError):
CPubKey.combine(k1.pub, k2.pub,
k1.pub.negated(), k2.pub.negated())
else:
logging.basicConfig()
log = logging.getLogger("Test_CKey")
log.warning('secp256k1 does not export pubkey negation function. '
'You should use newer version of secp256k1 library. '
'Tests that involve key substraction are skipped')
def test_p2sh_p2wpkh_signaturehash(self):
unsigned_tx = x(
'0100000001db6b1b20aa0fd7b23880be2ecbd4a98130974cf4748fb66092ac4d3ceb1a54770100000000feffffff02b8b4eb0b000000001976a914a457b684d7f0d539a46a45bbc043f35b59d0d96388ac0008af2f000000001976a914fd270b1ee6abcaea97fea7ad0402e8bd8ad6d77c88ac92040000'
)
scriptpubkey = CScript(
x('001479091972186c449eb1ded22b78e40d009bdf0089'))
value = coins_to_satoshi(10)
address = CCoinAddress.from_scriptPubKey(scriptpubkey)
self.assertEqual(
SignatureHash(address.to_redeemScript(),
CTransaction.deserialize(unsigned_tx), 0,
SIGHASH_ALL, value, SIGVERSION_WITNESS_V0),
x('64f3b0f4dd2bb3aa1ce8566d220cc74dda9df97d8490cc81d89d735c92e59fb6'
))
def test_p2wpkh_signaturehash(self):
unsigned_tx = x(
'0100000002fff7f7881a8099afa6940d42d1e7f6362bec38171ea3edf433541db4e4ad969f0000000000eeffffffef51e1b804cc89d182d279655c3aa89e815b1b309fe287d9b2b55d57b90ec68a0100000000ffffffff02202cb206000000001976a9148280b37df378db99f66f85c95a783a76ac7a6d5988ac9093510d000000001976a9143bde42dbee7e4dbe6a21b2d50ce2f0167faa815988ac11000000'
)
scriptpubkey = CScript(
x('00141d0f172a0ecb48aee1be1f2687d2963ae33f71a1'))
value = coins_to_satoshi(6)
address = CBech32BitcoinAddress.from_scriptPubKey(scriptpubkey)
self.assertEqual(
SignatureHash(address.to_redeemScript(),
CTransaction.deserialize(unsigned_tx), 1,
SIGHASH_ALL, value, SIGVERSION_WITNESS_V0),
x('c37af31116d1b27caf68aae9e3ac82f1477929014d5b917657d0eb49478cb670'
))
def getblockheader(self, block_hash, verbose=False):
"""Get block header <block_hash>
verbose - If true a dict is returned with the values returned by
getblockheader that are not in the block header itself
(height, nextblockhash, etc.)
Raises IndexError if block_hash is not valid.
"""
try:
block_hash = b2lx(block_hash)
except TypeError:
raise TypeError(
'%s.getblockheader(): block_hash must be bytes; got %r instance'
% (self.__class__.__name__, block_hash.__class__))
try:
r = self._call('getblockheader', block_hash, verbose)
except InvalidAddressOrKeyError as ex:
raise IndexError('%s.getblockheader(): %s (%d)' %
(self.__class__.__name__, ex.error['message'],
ex.error['code']))
if verbose:
nextblockhash = None
if 'nextblockhash' in r:
nextblockhash = lx(r['nextblockhash'])
return {
'confirmations': r['confirmations'],
'height': r['height'],
'mediantime': r['mediantime'],
'nextblockhash': nextblockhash,
'chainwork': x(r['chainwork'])
}
else:
return CBlockHeader.deserialize(unhexlify(r))
def test_from_bare_checksig_scriptPubKey(self):
def T(hex_scriptpubkey, expected_str_address):
scriptPubKey = CScript(x(hex_scriptpubkey))
# test that CBitcoinAddressError is raised, we do not support
# bare checksig
with self.assertRaises(CBitcoinAddressError):
P2PKHBitcoinAddress.from_scriptPubKey(scriptPubKey)
# compressed
T(
'21000000000000000000000000000000000000000000000000000000000000000000ac',
'14p5cGy5DZmtNMQwTQiytBvxMVuTmFMSyU')
# uncompressed
T(
'410000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000ac',
'13VmALKHkCdSN1JULkP6RqW3LcbpWvgryV')
# non-canonical encoding
T(
'4c21000000000000000000000000000000000000000000000000000000000000000000ac',
'14p5cGy5DZmtNMQwTQiytBvxMVuTmFMSyU')
# odd-lengths are *not* accepted
with self.assertRaises(CBitcoinAddressError):
P2PKHBitcoinAddress.from_scriptPubKey(
CScript(
x('2200000000000000000000000000000000000000000000000000000000000000000000ac'
)))
def load(cls):
with open(cls.PATH, "r") as rf:
wallet_json = json.load(rf)
wallet_xpub = ExtPubKey(wallet_json["wallet_xpub"])
master_fingerprint = x(wallet_json["master_fingerprint"])
base_keypath = HDKeyPath(wallet_json["base_keypath"])
current_block = Block.from_json(wallet_json["current_block"])
raw_external_addresses = wallet_json["external_addresses"]
raw_change_addresses = wallet_json["change_addresses"]
external_addresses = [
WalletAddress(
wallet_xpub, base_keypath, child_number, False,
address["was_recovered"], address["is_fresh"],
[Utxo.from_json(utxo) for utxo in address["utxos"]],
address.get("label"))
for child_number, address in enumerate(raw_external_addresses)
]
change_addresses = [
WalletAddress(
wallet_xpub, base_keypath, child_number, True,
address["was_recovered"], address["is_fresh"],
[Utxo.from_json(utxo) for utxo in address["utxos"]])
for child_number, address in enumerate(raw_change_addresses)
]
return (wallet_xpub, master_fingerprint, base_keypath,
current_block, external_addresses, change_addresses)
def test_from_bare_checksig_scriptPubKey(self):
def T(hex_scriptpubkey, expected_str_address):
scriptPubKey = CScript(x(hex_scriptpubkey))
addr = P2PKHBitcoinAddress.from_scriptPubKey(scriptPubKey)
self.assertEqual(str(addr), expected_str_address)
# now test that CBitcoinAddressError is raised with accept_non_canonical_pushdata=False
with self.assertRaises(CBitcoinAddressError):
P2PKHBitcoinAddress.from_scriptPubKey(
scriptPubKey, accept_bare_checksig=False)
# compressed
T(
'21000000000000000000000000000000000000000000000000000000000000000000ac',
'14p5cGy5DZmtNMQwTQiytBvxMVuTmFMSyU')
# uncompressed
T(
'410000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000ac',
'13VmALKHkCdSN1JULkP6RqW3LcbpWvgryV')
# non-canonical encoding
T(
'4c21000000000000000000000000000000000000000000000000000000000000000000ac',
'14p5cGy5DZmtNMQwTQiytBvxMVuTmFMSyU')
# odd-lengths are *not* accepted
with self.assertRaises(CBitcoinAddressError):
P2PKHBitcoinAddress.from_scriptPubKey(
x('2200000000000000000000000000000000000000000000000000000000000000000000ac'
))
def T(hex_pubkey: str,
is_nonempty: bool, is_fullyvalid: bool, is_compressed: bool
) -> None:
key = CPubKey(x(hex_pubkey))
self.assertEqual(key.is_nonempty(), is_nonempty)
self.assertEqual(key.is_fullyvalid(), is_fullyvalid)
self.assertEqual(key.is_compressed(), is_compressed)
def test_from_valid_pubkey(self) -> None:
"""Create P2PKHBitcoinAddress's from valid pubkeys"""
def T(pubkey: bytes, expected_str_addr: str) -> None:
addr = P2PKHBitcoinAddress.from_pubkey(pubkey)
self.assertEqual(str(addr), expected_str_addr)
T(x('0378d430274f8c5ec1321338151e9f27f4c676a008bdf8638d07c0b6be9ab35c71'),
'1C7zdTfnkzmr13HfA2vNm5SJYRK6nEKyq8')
T(x('0478d430274f8c5ec1321338151e9f27f4c676a008bdf8638d07c0b6be9ab35c71a1518063243acd4dfe96b66e3f2ec8013c8e072cd09b3834a19f81f659cc3455'),
'1JwSSubhmg6iPtRjtyqhUYYH7bZg3Lfy1T')
T(CPubKey(x('0378d430274f8c5ec1321338151e9f27f4c676a008bdf8638d07c0b6be9ab35c71')),
'1C7zdTfnkzmr13HfA2vNm5SJYRK6nEKyq8')
T(CPubKey(x('0478d430274f8c5ec1321338151e9f27f4c676a008bdf8638d07c0b6be9ab35c71a1518063243acd4dfe96b66e3f2ec8013c8e072cd09b3834a19f81f659cc3455')),
'1JwSSubhmg6iPtRjtyqhUYYH7bZg3Lfy1T')
def test_from_redeemScript(self) -> None:
def T(script: CScript, expected_str_address: str) -> None:
addr = P2SHBitcoinAddress.from_redeemScript(script)
self.assertEqual(str(addr), expected_str_address)
T(CScript(), '3J98t1WpEZ73CNmQviecrnyiWrnqRhWNLy')
T(CScript(x('76a914751e76e8199196d454941c45d1b3a323f1433bd688ac')),
'3LRW7jeCvQCRdPF8S3yUCfRAx4eqXFmdcr')
def test_standard_bip32_vectors(self):
for vector in BIP32_TEST_VECTORS:
_, seed = vector[0]
key = CBitcoinExtKey.from_seed(x(seed))
for xpub, xpriv, child_num in vector[1:]:
self.assertEqual(xpub, str(key.neuter()))
self.assertEqual(xpriv, str(key))
key = key.derive(child_num)
def T(hex_scriptpubkey, expected_str_address):
scriptPubKey = CScript(x(hex_scriptpubkey))
addr = P2PKHBitcoinAddress.from_scriptPubKey(scriptPubKey)
self.assertEqual(str(addr), expected_str_address)
# now test that CBitcoinAddressError is raised with accept_non_canonical_pushdata=False
with self.assertRaises(CBitcoinAddressError):
P2PKHBitcoinAddress.from_scriptPubKey(
scriptPubKey, accept_bare_checksig=False)
def T(serialized_script, expected_tokens, test_roundtrip=True):
serialized_script = x(serialized_script)
script_obj = CScript(serialized_script)
actual_tokens = list(script_obj)
self.assertEqual(actual_tokens, expected_tokens)
if test_roundtrip:
recreated_script = CScript(actual_tokens)
self.assertEqual(recreated_script, serialized_script)
def load_test_vectors(name):
with open(os.path.dirname(__file__) + '/data/' + name, 'r') as fd:
for tx_decoded in json.load(fd):
if isinstance(tx_decoded, str):
continue # skip comment
tx_bytes = x(tx_decoded['hex'])
assert len(tx_bytes) == tx_decoded['size']
tx = CTransaction.deserialize(tx_bytes)
yield (tx_decoded, tx, tx_bytes)
def sign_input(tx, input_index, utxo):
"""Sign an input of transaction.
Single-signature signing with SIGHASH_ALL"""
key = utxo['key']
src_addr = CCoinAddress(utxo['address'])
script_for_sighash = CScript(
[OP_DUP, OP_HASH160,
Hash160(key.pub), OP_EQUALVERIFY, OP_CHECKSIG])
assert isinstance(src_addr, (P2PKHCoinAddress, P2SHCoinAddress,
P2WPKHCoinAddress)),\
'only p2pkh, p2wpkh and p2sh_p2wpkh addresses are supported'
if isinstance(src_addr, P2PKHCoinAddress):
sigversion = SIGVERSION_BASE
else:
sigversion = SIGVERSION_WITNESS_V0
if 'amountcommitment' in utxo:
amountcommitment = CConfidentialValue(x(utxo['amountcommitment']))
else:
amountcommitment = CConfidentialValue(coins_to_satoshi(utxo['amount']))
sighash = script_for_sighash.sighash(tx,
input_index,
SIGHASH_ALL,
amount=amountcommitment,
sigversion=sigversion)
sig = key.sign(sighash) + bytes([SIGHASH_ALL])
if isinstance(src_addr, P2PKHCoinAddress):
tx.vin[input_index].scriptSig = CScript(
[CScript(sig), CScript(key.pub)])
scriptpubkey = src_addr.to_scriptPubKey()
elif isinstance(src_addr, P2WPKHCoinAddress):
tx.vin[input_index].scriptSig = CScript()
tx.wit.vtxinwit[input_index] = CTxInWitness(
CScriptWitness([CScript(sig), CScript(key.pub)]))
scriptpubkey = src_addr.to_scriptPubKey()
else:
# Assume that this is p2sh-wrapped p2wpkh address
inner_scriptPubKey = CScript([0, Hash160(key.pub)])
tx.vin[input_index].scriptSig = CScript([inner_scriptPubKey])
tx.wit.vtxinwit[input_index] = CTxInWitness(
CScriptWitness([CScript(sig), CScript(key.pub)]))
scriptpubkey = inner_scriptPubKey.to_p2sh_scriptPubKey()
VerifyScript(tx.vin[input_index].scriptSig,
scriptpubkey,
tx,
input_index,
amount=amountcommitment,
flags=(SCRIPT_VERIFY_P2SH, ))
def check_sign(self, blinded_tx: CTransaction, signed_tx: CTransaction,
bundle: Dict[str, Any]) -> None:
tx_to_sign = blinded_tx.to_mutable()
for n, vin in enumerate(tx_to_sign.vin):
utxo = bundle['vin_utxo'][n]
amount = -1 if utxo['amount'] == -1 else coins_to_satoshi(
utxo['amount'])
scriptPubKey = CScript(x(utxo['scriptPubKey']))
a = CCoinAddress(utxo['address'])
if 'privkey' in utxo:
privkey = CCoinKey(utxo['privkey'])
assert isinstance(a, P2PKHCoinAddress),\
"only P2PKH is supported for single-sig"
assert a == P2PKHElementsAddress.from_pubkey(privkey.pub)
assert scriptPubKey == a.to_scriptPubKey()
sighash = SignatureHash(scriptPubKey,
tx_to_sign,
n,
SIGHASH_ALL,
amount=amount,
sigversion=SIGVERSION_BASE)
sig = privkey.sign(sighash) + bytes([SIGHASH_ALL])
tx_to_sign.vin[n].scriptSig = CScript(
[CScript(sig), CScript(privkey.pub)])
else:
pk_list = [CCoinKey(pk) for pk in utxo['privkey_list']]
redeem_script_data = [utxo['num_p2sh_participants']]
redeem_script_data.extend([pk.pub for pk in pk_list])
redeem_script_data.extend([len(pk_list), OP_CHECKMULTISIG])
redeem_script = CScript(redeem_script_data)
assert isinstance(a, P2SHCoinAddress),\
"only P2SH is supported for multi-sig."
assert scriptPubKey == redeem_script.to_p2sh_scriptPubKey()
assert a == P2SHElementsAddress.from_scriptPubKey(
redeem_script.to_p2sh_scriptPubKey())
sighash = SignatureHash(redeem_script,
tx_to_sign,
n,
SIGHASH_ALL,
amount=amount,
sigversion=SIGVERSION_BASE)
sigs = [
pk.sign(sighash) + bytes([SIGHASH_ALL]) for pk in pk_list
]
tx_to_sign.vin[n].scriptSig = CScript([b''] + sigs +
[redeem_script])
VerifyScript(tx_to_sign.vin[n].scriptSig,
scriptPubKey,
tx_to_sign,
n,
amount=amount)
self.assertEqual(tx_to_sign.serialize(), signed_tx.serialize())
def T(serialized_script_str: str,
expected_tokens: List[Union[bytes, int]],
test_roundtrip: bool = True) -> None:
serialized_script = x(serialized_script_str)
script_obj = CScript(serialized_script)
actual_tokens = list(script_obj)
self.assertEqual(actual_tokens, expected_tokens)
if test_roundtrip:
recreated_script = CScript(actual_tokens)
self.assertEqual(recreated_script, serialized_script)
def test_from_invalid_pubkeys(self) -> None:
"""Create P2PKHBitcoinAddress's from invalid pubkeys"""
# first test with accept_invalid=True
def T(invalid_pubkey: bytes, expected_str_addr: str) -> None:
addr = P2PKHBitcoinAddress.from_pubkey(invalid_pubkey, accept_invalid=True)
self.assertEqual(str(addr), expected_str_addr)
T(x(''),
'1HT7xU2Ngenf7D4yocz2SAcnNLW7rK8d4E')
T(x('0378d430274f8c5ec1321338151e9f27f4c676a008bdf8638d07c0b6be9ab35c72'),
'1L9V4NXbNtZsLjrD3nkU7gtEYLWRBWXLiZ')
# With accept_invalid=False we should get CBitcoinAddressError's
with self.assertRaises(CBitcoinAddressError):
P2PKHBitcoinAddress.from_pubkey(x(''))
with self.assertRaises(CBitcoinAddressError):
P2PKHBitcoinAddress.from_pubkey(x('0378d430274f8c5ec1321338151e9f27f4c676a008bdf8638d07c0b6be9ab35c72'))
with self.assertRaises(CBitcoinAddressError):
P2PKHBitcoinAddress.from_pubkey(CPubKey(x('0378d430274f8c5ec1321338151e9f27f4c676a008bdf8638d07c0b6be9ab35c72')))
def try_reclaim_elt(say, elt_rpc, txid, elt_contract, key, blinding_key, die):
ensure_rpc_connected(say, elt_rpc)
# we won't return from this function, so we can just
# set the chain with select_chain_params
select_chain_params(elements_chain_name)
from_addr = P2SHCoinAddress.from_redeemScript(elt_contract)
say('Will try to reclaim my Elements bitcoin asset from {}'.format(
from_addr))
tx_json = elt_rpc.getrawtransaction(txid, 1)
confirmations = int(tx_json['confirmations'])
while confirmations < elements_contract_timeout:
tx_json = elt_rpc.getrawtransaction(txid, 1)
confirmations = int(tx_json['confirmations'])
commit_tx = CElementsTransaction.deserialize(x(tx_json['hex']))
vout_n, unblind_result = find_and_unblind_vout(say, commit_tx, from_addr,
blinding_key, die)
dst_addr = CElementsAddress(elt_rpc.getnewaddress())
say('Will reclaim my Elements asset to {}'.format(dst_addr))
reclaim_tx = create_elt_spend_tx(
dst_addr,
txid,
vout_n,
elt_contract,
die,
spend_key=key,
blinding_factor=unblind_result.blinding_factor,
asset_blinding_factor=unblind_result.asset_blinding_factor,
branch_condition=False)
say('Sending my Elements-reclaim transaction')
new_txid = elt_rpc.sendrawtransaction(b2x(reclaim_tx.serialize()))
def custom_die(msg):
say(msg)
die('Failed to reclaim by Elemets asset')
wait_confirm(say,
'Elements',
new_txid,
custom_die,
elt_rpc,
num_confirms=3)
say('Reclaimed my Elements asset. Swap failed.')
def test_repr(self):
def T(script, expected_repr):
actual_repr = repr(script)
self.assertEqual(actual_repr, expected_repr)
T(CScript([]),
'CBitcoinScript([])')
T(CScript([1]),
'CBitcoinScript([1])')
T(CScript([1, 2, 3]),
'CBitcoinScript([1, 2, 3])')
T(CScript([1, x('7ac977d8373df875eceda362298e5d09d4b72b53'), OP_DROP]),
"CBitcoinScript([1, x('7ac977d8373df875eceda362298e5d09d4b72b53'), OP_DROP])")
T(CScript(x('0001ff515261ff')),
"CBitcoinScript([0, x('ff'), 1, 2, OP_NOP, OP_INVALIDOPCODE])")
# truncated scripts
T(CScript(x('6101')),
"CBitcoinScript([OP_NOP, x('')...<ERROR: PUSHDATA(1): truncated data>])")
T(CScript(x('614bff')),
"CBitcoinScript([OP_NOP, x('ff')...<ERROR: PUSHDATA(75): truncated data>])")
T(CScript(x('614c')),
"CBitcoinScript([OP_NOP, <ERROR: PUSHDATA1: missing data length>])")
T(CScript(x('614c0200')),
"CBitcoinScript([OP_NOP, x('00')...<ERROR: PUSHDATA1: truncated data>])")
def test_standard_bip32_vectors(self):
for vector in BIP32_TEST_VECTORS:
_, seed = vector[0]
base_key = CBitcoinExtKey.from_seed(x(seed))
key = base_key
path = []
for xpub, xpriv, child_num in vector[1:]:
self.assertEqual(xpub, str(key.neuter()))
self.assertEqual(xpriv, str(key))
key = key.derive(child_num)
path.append(child_num)
key_from_path = base_key.derive_path(str(BIP32Path(path)))
self.assertEqual(key, key_from_path)
def test(self):
def T(confidential_addr, expected_bytes, unconfidential_addr,
expected_blinding_pubkey, expected_class):
a = CCoinAddress(confidential_addr)
self.assertIsInstance(a, expected_class)
self.assertEqual(a.to_bytes(), expected_bytes)
self.assertEqual(unconfidential_addr, a.to_unconfidential())
self.assertEqual(
confidential_addr,
str(a.__class__.from_unconfidential(
unconfidential_addr, a.blinding_pubkey)))
self.assertEqual(expected_blinding_pubkey, a.blinding_pubkey)
a2 = CCoinConfidentialAddress(str(a))
self.assertEqual(a, a2)
a2 = CCoinConfidentialAddress.from_unconfidential(unconfidential_addr,
a.blinding_pubkey)
self.assertEqual(a, a2)
T('CTEp1wviJ6U7SdAAs5sRJ1NzzRzAbmQGt1veiswjWrkzv98W7UJMQjBccafpS6v9w6evWTqeLsGc7TC1',
x('029ffb47606c3d672a3429d91650960c63ff7d8f8ff9e00b4a8e3430c6549b4cc83422fe11c415bb9c8618f9d8498d9ad945056bdb'),
P2PKHElementsAddress('2deBRSp69HSsJ5WAegsaksoWj8PfaQ2PqDd'),
x('029ffb47606c3d672a3429d91650960c63ff7d8f8ff9e00b4a8e3430c6549b4cc8'),
P2PKHElementsConfidentialAddress)
def test_p2wsh_signaturehash1(self):
unsigned_tx = x(
'0100000002fe3dc9208094f3ffd12645477b3dc56f60ec4fa8e6f5d67c565d1c6b9216b36e0000000000ffffffff0815cf020f013ed6cf91d29f4202e8a58726b1ac6c79da47c23d1bee0a6925f80000000000ffffffff0100f2052a010000001976a914a30741f8145e5acadf23f751864167f32e0963f788ac00000000'
)
value2 = coins_to_satoshi(49)
scriptcode1 = CScript(
x('21026dccc749adc2a9d0d89497ac511f760f45c47dc5ed9cf352a58ac706453880aeadab210255a9626aebf5e29c0e6538428ba0d1dcf6ca98ffdf086aa8ced5e0d0215ea465ac'
))
# This is the same script with everything up to the last executed OP_CODESEPARATOR, including that
# OP_CODESEPARATOR removed
scriptcode2 = CScript(
x('210255a9626aebf5e29c0e6538428ba0d1dcf6ca98ffdf086aa8ced5e0d0215ea465ac'
))
self.assertEqual(
SignatureHash(scriptcode1, CTransaction.deserialize(unsigned_tx),
1, SIGHASH_SINGLE, value2, SIGVERSION_WITNESS_V0),
x('82dde6e4f1e94d02c2b7ad03d2115d691f48d064e9d52f58194a6637e4194391'
))
self.assertEqual(
SignatureHash(scriptcode2, CTransaction.deserialize(unsigned_tx),
1, SIGHASH_SINGLE, value2, SIGVERSION_WITNESS_V0),
x('fef7bd749cce710c5c052bd796df1af0d935e59cea63736268bcbe2d2134fc47'
))
def test_from_non_canonical_scriptPubKey(self) -> None:
def T(hex_scriptpubkey: str, expected_str_address: str) -> None:
scriptPubKey = CScript(x(hex_scriptpubkey))
# now test that CBitcoinAddressError is raised, non-canonical
# pushdata is not allowed
with self.assertRaises(CBitcoinAddressError):
P2PKHBitcoinAddress.from_scriptPubKey(scriptPubKey)
T('76a94c14000000000000000000000000000000000000000088ac', '1111111111111111111114oLvT2')
T('76a94d1400000000000000000000000000000000000000000088ac', '1111111111111111111114oLvT2')
T('76a94e14000000000000000000000000000000000000000000000088ac', '1111111111111111111114oLvT2')
# make sure invalid scripts raise CBitcoinAddressError
with self.assertRaises(CBitcoinAddressError):
P2PKHBitcoinAddress.from_scriptPubKey(CScript(x('76a94c14')))
def test_get_output_size(self):
pub1 = CPubKey(
x('0378d430274f8c5ec1321338151e9f27f4c676a008bdf8638d07c0b6be9ab35c71'
))
pub2 = CPubKey(
x('02546c76587482cd2468b76768da70c0166ecb2aa2eb1038624f4fedc138b042bc'
))
for chainparam in get_params_list():
with ChainParams(chainparam):
smpl = get_unconfidential_address_samples(pub1, pub2)
# 1 byte for 'no asset', 1 byte for 'no nonce',
# 9 bytes for explicit value,
# minus 8 bytes of len of bitcoin nValue
elements_unconfidential_size_extra = 1 + 1 + 9 - 8
# 33 bytes for asset, 33 bytes for nonce,
# 33 bytes for confidential value,
# minus 8 bytes of len of bitcoin nValue
elements_confidential_size_extra = 33 + 33 + 33 - 8
self.assertEqual(smpl.p2pkh.get_output_size(),
34 + elements_unconfidential_size_extra)
self.assertEqual(smpl.p2wpkh.get_output_size(),
31 + elements_unconfidential_size_extra)
self.assertEqual(smpl.p2sh.get_output_size(),
32 + elements_unconfidential_size_extra)
self.assertEqual(smpl.p2wsh.get_output_size(),
43 + elements_unconfidential_size_extra)
self.assertEqual(smpl.conf_p2pkh.get_output_size(),
34 + elements_confidential_size_extra)
self.assertEqual(smpl.conf_p2wpkh.get_output_size(),
31 + elements_confidential_size_extra)
self.assertEqual(smpl.conf_p2sh.get_output_size(),
32 + elements_confidential_size_extra)
self.assertEqual(smpl.conf_p2wsh.get_output_size(),
43 + elements_confidential_size_extra)
class CoreLitecoinParams(CoreChainParams):
NAME = 'litecoin-mainnet'
GENESIS_BLOCK = CBlock.deserialize(x(
'0100000000000000000000000000000000000000000000000000000000000000'
'00000000d9ced4ed1130f7b7faad9be25323ffafa33232a17c3edf6cfd97bee6'
'bafbdd97b9aa8e4ef0ff0f1ecd513f7c01010000000100000000000000000000'
'00000000000000000000000000000000000000000000ffffffff4804ffff001d'
'0104404e592054696d65732030352f4f63742f32303131205374657665204a6f'
'62732c204170706c65e280997320566973696f6e6172792c2044696573206174'
'203536ffffffff0100f2052a010000004341040184710fa689ad5023690c80f3'
'a49c8f13f8d45b8c857fbcbc8bc4a8e4d3eb4b10f4d4604fa08dce601aaf0f47'
'0216fe1b51850b4acf21b179c45070ac7b03a9ac00000000'))
SUBSIDY_HALVING_INTERVAL = 840000
PROOF_OF_WORK_LIMIT = 2 ** 256 - 1 >> 20
MAX_MONEY = 84000000 * COIN
def request_sign_transaction(
self, psbt: PartiallySignedTransaction) -> Transaction:
message = json.dumps({
"header": OutgoingMessageHeader.REQUEST_SIGN_TRANSACTION,
"payload": {
"psbt": psbt.serialize().hex()
}
})
self.write_message(message)
response = self.read_message(
IncomingMessageHeader.SIGN_TRANSACTION_RESULT)
payload = response["payload"]
if not bool(payload["success"]):
return None
psbt = PartiallySignedTransaction.deserialize(x(payload["psbt"]))
return psbt.extract_transaction()
def test_get_output_size(self) -> None:
pub = CPubKey(x('0378d430274f8c5ec1321338151e9f27f4c676a008bdf8638d07c0b6be9ab35c71'))
a0 = P2PKHCoinAddress.from_pubkey(pub)
self.assertEqual(P2PKHCoinAddress.get_output_size(), 34)
self.assertEqual(a0.get_output_size(), 34)
a1 = P2WPKHCoinAddress.from_pubkey(pub)
self.assertEqual(P2WPKHCoinAddress.get_output_size(), 31)
self.assertEqual(a1.get_output_size(), 31)
a2 = P2SHCoinAddress.from_redeemScript(
CScript(b'\xa9' + Hash160(pub) + b'\x87'))
self.assertEqual(P2SHCoinAddress.get_output_size(), 32)
self.assertEqual(a2.get_output_size(), 32)
a3 = P2WSHCoinAddress.from_redeemScript(
CScript(b'\xa9' + Hash160(pub) + b'\x87'))
self.assertEqual(P2WSHCoinAddress.get_output_size(), 43)
self.assertEqual(a3.get_output_size(), 43)
