def test_MoneyRangeCustomParams(self):
class CoreHighMaxClassDispatcher(CoreBitcoinClassDispatcher):
...
class CoreHighMaxParams(CoreBitcoinParams, CoreBitcoinClass):
@classgetter
def MAX_MONEY(self):
return 22000000 * self.COIN
class WalletHighMaxClassDispatcher(WalletBitcoinClassDispatcher):
...
class HighMaxParams(BitcoinMainnetParams):
NAME = 'high_maxmoney'
WALLET_DISPATCHER = WalletHighMaxClassDispatcher
with ChainParams(HighMaxParams):
self.assertFalse(MoneyRange(-1))
with self.assertRaises(ValueError):
coins_to_satoshi(-1)
with self.assertRaises(ValueError):
satoshi_to_coins(-1)
self.assertTrue(MoneyRange(0))
self.assertTrue(MoneyRange(100000))
max_satoshi = coins_to_satoshi(22000000)
self.assertTrue(
MoneyRange(max_satoshi)) # Maximum money on Bitcoin network
self.assertFalse(MoneyRange(max_satoshi + 1))
with self.assertRaises(ValueError):
coins_to_satoshi(max_satoshi + 1)
with self.assertRaises(ValueError):
satoshi_to_coins(max_satoshi + 1)
def test_MoneyRange(self):
self.assertFalse(MoneyRange(-1))
with self.assertRaises(ValueError):
coins_to_satoshi(-1)
with self.assertRaises(ValueError):
satoshi_to_coins(-1)
self.assertTrue(MoneyRange(0))
self.assertTrue(MoneyRange(100000))
max_satoshi = coins_to_satoshi(21000000)
self.assertTrue(
MoneyRange(max_satoshi)) # Maximum money on Bitcoin network
self.assertFalse(MoneyRange(max_satoshi + 1))
with self.assertRaises(ValueError):
coins_to_satoshi(max_satoshi + 1)
with self.assertRaises(ValueError):
satoshi_to_coins(max_satoshi + 1)
def get_max_spend_btc(self) -> float:
address_str = self.address_input_text
address = (ExternalAddress(address_str)
if self.address_is_valid(address_str) else None)
max_spend_satosis = self.controller.get_max_possible_spend(
self.priority_fee_selected, address)
return satoshi_to_coins(max_spend_satosis)
def test_MoneyRangeCustomParams(self) -> None:
class CoreHighMaxClassDispatcher(CoreBitcoinClassDispatcher):
...
class CoreHighMaxClass(CoreBitcoinClass,
metaclass=CoreHighMaxClassDispatcher):
...
class CoreHighMaxParams(CoreBitcoinParams, CoreHighMaxClass):
@classgetter
def MAX_MONEY(self) -> int:
return 10**100 * self.COIN
class WalletHighMaxClassDispatcher(WalletBitcoinClassDispatcher,
depends=[
CoreHighMaxClassDispatcher
]):
...
class HighMaxParams(BitcoinMainnetParams):
NAME = 'high_maxmoney'
WALLET_DISPATCHER = WalletHighMaxClassDispatcher
with self.assertRaises(ValueError):
coins_to_satoshi(10**100)
with ChainParams(HighMaxParams):
self.assertFalse(MoneyRange(-1))
with self.assertRaises(ValueError):
coins_to_satoshi(-1)
with self.assertRaises(ValueError):
satoshi_to_coins(-1)
self.assertTrue(MoneyRange(0))
self.assertTrue(MoneyRange(100000))
max_satoshi = coins_to_satoshi(10**100)
self.assertEqual(satoshi_to_coins(max_satoshi), 10**100)
self.assertTrue(MoneyRange(max_satoshi))
self.assertFalse(MoneyRange(max_satoshi + 1))
with self.assertRaises(ValueError):
coins_to_satoshi(max_satoshi + 1)
with self.assertRaises(ValueError):
satoshi_to_coins(max_satoshi + 1)
def display_balance(self):
balance_units = Config.get_balance_units()
if balance_units == BalanceUnits.BTC:
spendable_balance_text = str(
satoshi_to_coins(self.spendable_balance))
incoming_balance_text = str(satoshi_to_coins(
self.incoming_balance))
elif balance_units == BalanceUnits.SATOSHIS:
spendable_balance_text = str(self.spendable_balance)
incoming_balance_text = str(self.incoming_balance)
currency_symbol = get_currency_symbol(self.controller.network,
balance_units)
balance_text = self.SPENDABLE_BALANCE_TEMPLATE.format(
balance=spendable_balance_text, currency_symbol=currency_symbol)
if self.incoming_balance > 0:
incoming_balance_text = self.INCOMING_BALANCE_TEMPLATE.format(
balance=incoming_balance_text, currency_symbol=currency_symbol)
balance_text += incoming_balance_text
self.balance_label.setText(balance_text)
print("")
for n, vout in enumerate(tx.vout):
# Note that nValue of vout in Elements is not a simple int,
# but CConfidentialValue, which can either be explicit, and can be
# converted to satoshis with to_amount(), or it can be blinded, in
# which case you need to unblind the output to know its value.
if vout.nValue.is_explicit():
# The output is not blinded, we can access the values right away
assert vout.nAsset.is_explicit(), "unblinding just the asset is not supported"
if vout.is_fee():
print("vout {}: fee".format(n))
else:
print("vout {}: explicit".format(n))
print(" destination address:",
CCoinAddress.from_scriptPubKey(tx.vout[n].scriptPubKey))
print(" amount:\t\t", satoshi_to_coins(vout.nValue.to_amount()))
print(" asset:\t\t", vout.nAsset.to_asset())
else:
# Try to unblind the output with the given blinding key
result = vout.unblind_confidential_pair(
bkey, tx.wit.vtxoutwit[n].rangeproof)
if result.error:
# Nope, our blinding key is not good for this output
print("vout {}: cannot unblind: {}".format(n, result.error))
print(" destination address:",
CCoinAddress.from_scriptPubKey(tx.vout[n].scriptPubKey))
if not tx.wit.is_null():
rpinfo = tx.wit.vtxoutwit[n].get_rangeproof_info()
if rpinfo:
print(' ct-exponent', rpinfo.exp)
def bob(say, recv, send, die, btc_rpc, elt_rpc):
"""A function that implements the logic
of the Bitcoin-side participant
of confidential cross-chain atomic swap"""
global last_wish_func
# Default chain for Bob will be Bitcoin
# To handle bitcoin-related objects, either
# `with ChainParams(elements_chain_name):` have to be used, or
# concrete classes, like CElementsAddress, CElementsTransaction, etc.
select_chain_params(bitcoin_chain_name)
say('Waiting for blinding key from Alice')
alice_btc_pub_raw, alice_elt_exit_pub_raw = recv('pubkeys')
blinding_key = CKey.from_secret_bytes(recv('blinding_key'))
say("Pubkey for blinding key: {}".format(b2x(blinding_key.pub)))
# Let's create the key that would lock the coins on Bitcoin side
contract_key = CKey.from_secret_bytes(os.urandom(32))
# And the key for Elements side
bob_elt_spend_key = CKey.from_secret_bytes(os.urandom(32))
# And the key for 'timeout' case on btc side
bob_btc_exit_key = CKey.from_secret_bytes(os.urandom(32))
key_to_reveal_pub = CPubKey.add(contract_key.pub, blinding_key.pub)
say("The pubkey of the combined key to be revealed: {}".format(
b2x(key_to_reveal_pub)))
say('Sending my pubkeys to Alice')
send('pubkeys',
(contract_key.pub, bob_elt_spend_key.pub, bob_btc_exit_key.pub))
combined_btc_spend_pubkey = CPubKey.add(contract_key.pub,
CPubKey(alice_btc_pub_raw))
say('combined_btc_spend_pubkey: {}'.format(b2x(combined_btc_spend_pubkey)))
btc_contract = make_btc_contract(combined_btc_spend_pubkey,
bob_btc_exit_key.pub)
btc_contract_addr = P2WSHCoinAddress.from_redeemScript(btc_contract)
say("Created Bitcoin-side swap contract, size: {}".format(
len(btc_contract)))
say("Contract address: {}".format(btc_contract_addr))
say('Sending {} to {}'.format(pre_agreed_amount, btc_contract_addr))
btc_txid = btc_rpc.sendtoaddress(str(btc_contract_addr), pre_agreed_amount)
def bob_last_wish_func():
try_reclaim_btc(say, btc_rpc, btc_txid, btc_contract, bob_btc_exit_key,
die)
last_wish_func = bob_last_wish_func
wait_confirm(say, 'Bitcoin', btc_txid, die, btc_rpc, num_confirms=6)
send('btc_txid', btc_txid)
elt_txid = recv('elt_txid')
elt_contract = make_elt_cntract(key_to_reveal_pub, bob_elt_spend_key.pub,
alice_elt_exit_pub_raw)
with ChainParams(elements_chain_name):
elt_contract_addr = P2SHCoinAddress.from_redeemScript(elt_contract)
say('Got Elements contract address from Alice: {}'.format(
elt_contract_addr))
say('Looking for this address in transaction {} in Elements'.format(
elt_txid))
tx_json = elt_rpc.getrawtransaction(elt_txid, 1)
if tx_json['confirmations'] < 2:
die('Transaction does not have enough confirmations')
elt_commit_tx = CElementsTransaction.deserialize(x(tx_json['hex']))
vout_n, unblind_result = find_and_unblind_vout(say, elt_commit_tx,
elt_contract_addr,
blinding_key, die)
if unblind_result.amount != coins_to_satoshi(pre_agreed_amount):
die('the amount {} found at the output in the offered transaction '
'does not match the expected amount {}'.format(
satoshi_to_coins(unblind_result.amount), pre_agreed_amount))
say('The asset and amount match expected values. lets spend it.')
with ChainParams(elements_chain_name):
dst_addr = CCoinAddress(elt_rpc.getnewaddress())
assert isinstance(dst_addr, CCoinConfidentialAddress)
say('I will claim my Elements-BTC to {}'.format(dst_addr))
elt_claim_tx = create_elt_spend_tx(
dst_addr,
elt_txid,
vout_n,
elt_contract,
die,
spend_key=bob_elt_spend_key,
contract_key=contract_key,
blinding_key=blinding_key,
blinding_factor=unblind_result.blinding_factor,
asset_blinding_factor=unblind_result.asset_blinding_factor)
# Cannot use VerifyScript for now,
# because it does not support CHECKSIGFROMSTACK yet
#
# VerifyScript(tx.vin[0].scriptSig,
# elt_contract_addr.to_scriptPubKey(),
# tx, 0, amount=amount)
say('Sending my spend-reveal transaction')
sr_txid = elt_rpc.sendrawtransaction(b2x(elt_claim_tx.serialize()))
wait_confirm(say, 'Elements', sr_txid, die, elt_rpc, num_confirms=2)
say('Got my Elements-BTC. Swap successful (at least for me :-)')
def alice(say, recv, send, die, btc_rpc, elt_rpc):
"""A function that implements the logic
of the Elements-side participant
of confidential cross-chain atomic swap"""
global last_wish_func
# Default chain for Alice will be Elements
# To handle bitcoin-related objects, either
# `with ChainParams(bitcoin_chain_name):` have to be used, or
# concrete classes, like CBitcoinAddress, CBitcoinTransaction, etc.
select_chain_params(elements_chain_name)
# Let's create the shared blinding key
blinding_key = CKey.from_secret_bytes(os.urandom(32))
# And the key for btc spend
alice_btc_key = CKey.from_secret_bytes(os.urandom(32))
# And the key for the 'timeout' branch of the contract
alice_elt_exit_key = CKey.from_secret_bytes(os.urandom(32))
say('Sending pubkeys to Bob')
send('pubkeys', (alice_btc_key.pub, alice_elt_exit_key.pub))
say('Sending the blinding key to Bob')
send('blinding_key', blinding_key.secret_bytes)
(contract_pubkey_raw, bob_elt_pubkey_raw,
bob_btc_exit_pub_raw) = recv('pubkeys')
say("Pubkey of the key to be revealed: {}".format(
b2x(contract_pubkey_raw)))
say("Bob's Elements-side pubkey: {}".format(b2x(bob_elt_pubkey_raw)))
contract_pubkey = CPubKey(contract_pubkey_raw)
key_to_reveal_pub = CPubKey.add(contract_pubkey, blinding_key.pub)
elt_contract = make_elt_cntract(key_to_reveal_pub, bob_elt_pubkey_raw,
alice_elt_exit_key.pub)
elt_contract_addr = P2SHCoinAddress.from_redeemScript(elt_contract)
confidential_contract_addr = P2SHCoinConfidentialAddress.from_unconfidential(
elt_contract_addr, blinding_key.pub)
assert isinstance(confidential_contract_addr, CElementsConfidentialAddress)
say("Created Elemets-side swap contract, size: {}".format(
len(elt_contract)))
say("Contract address:\n\tconfidential: {}\n\tunconfidential: {}".format(
confidential_contract_addr, elt_contract_addr))
btc_txid = recv('btc_txid')
combined_btc_spend_pubkey = CPubKey.add(contract_pubkey, alice_btc_key.pub)
btc_contract = make_btc_contract(combined_btc_spend_pubkey,
bob_btc_exit_pub_raw)
tx_json = btc_rpc.getrawtransaction(btc_txid, 1)
if tx_json['confirmations'] < 6:
die('Transaction does not have enough confirmations')
# We use ChainParams, and not P2WSHBitcoinAddress here,
# because bitcoin_chain_name might be 'bitcoin/regtest', for example,
# and then the address would need to be P2WSHBitcoinRegtestAddress.
# with ChainParams we leverage the 'frontend class' magic, P2WSHCoinAddress
# will give us appropriate instance.
with ChainParams(bitcoin_chain_name):
btc_contract_addr = P2WSHCoinAddress.from_redeemScript(btc_contract)
say('Looking for this address in transaction {} in Bitcoin'.format(
btc_txid))
# CTransaction subclasses do not change between mainnet/testnet/regtest,
# so we can directly use CBitcoinTransaction.
# That might not be true for other chains, though.
# You might also want to use CTransaction within `with ChainParams(...):`
btc_tx = CBitcoinTransaction.deserialize(x(tx_json['hex']))
for n, vout in enumerate(btc_tx.vout):
if vout.scriptPubKey == btc_contract_addr.to_scriptPubKey():
say("Found the address at output {}".format(n))
btc_vout_n = n
break
else:
die('Did not find contract address in transaction')
if vout.nValue != coins_to_satoshi(pre_agreed_amount):
die('the amount {} found at the output in the offered transaction '
'does not match the expected amount {}'.format(
satoshi_to_coins(vout.nValue), pre_agreed_amount))
say('Bitcoin amount match expected values')
say('Sending {} to {}'.format(pre_agreed_amount,
confidential_contract_addr))
contract_txid = elt_rpc.sendtoaddress(str(confidential_contract_addr),
pre_agreed_amount)
def alice_last_wish_func():
try_reclaim_elt(say, elt_rpc, contract_txid, elt_contract,
alice_elt_exit_key, blinding_key, die)
last_wish_func = alice_last_wish_func
wait_confirm(say, 'Elements', contract_txid, die, elt_rpc, num_confirms=2)
send('elt_txid', contract_txid)
sr_txid = wait_spend_reveal_transaction(say, contract_txid, die, elt_rpc)
say('Got txid for spend-reveal transaction from Bob ({})'.format(sr_txid))
tx_json = elt_rpc.getrawtransaction(sr_txid, 1)
wait_confirm(say, 'Elements', sr_txid, die, elt_rpc, num_confirms=2)
sr_tx = CTransaction.deserialize(x(tx_json['hex']))
for n, vin in enumerate(sr_tx.vin):
if vin.prevout.hash == lx(contract_txid)\
and vin.scriptSig[-(len(elt_contract)):] == elt_contract:
say('Transaction input {} seems to contain a script '
'we can recover the key from'.format(n))
reveal_script_iter = iter(vin.scriptSig)
break
else:
die('Spend-reveal transaction does not have input that spends '
'the contract output')
next(reveal_script_iter) # skip Bob's spend signature
try:
# 2 skipped bytes are tag and len
sig_s = ecdsa.util.string_to_number(next(reveal_script_iter)[2:])
except (ValueError, StopIteration):
die('Reveal script is invalid')
k, r = get_known_k_r()
order = ecdsa.SECP256k1.order
mhash = ecdsa.util.string_to_number(hashlib.sha256(b'\x01').digest())
r_inverse = ecdsa.numbertheory.inverse_mod(r, order)
for s in (-sig_s, sig_s):
secret_exponent = (((s * k - mhash) % order) * r_inverse) % order
recovered_key = CKey.from_secret_bytes(
ecdsa.util.number_to_string(secret_exponent, order))
if recovered_key.pub == key_to_reveal_pub:
break
else:
die('Key recovery failed. Should not happen - the sig was already '
'verified when transaction was accepted into mempool. '
'Must be a bug.')
say('recovered key pubkey: {}'.format(b2x(recovered_key.pub)))
contract_key = CKey.sub(recovered_key, blinding_key)
say('recovered unblined key pubkey: {}'.format(b2x(contract_key.pub)))
combined_btc_spend_key = CKey.add(contract_key, alice_btc_key)
say('Successfully recovered the key. Can now spend Bitcoin from {}'.format(
btc_contract_addr))
with ChainParams(bitcoin_chain_name):
dst_addr = CCoinAddress(btc_rpc.getnewaddress())
btc_claim_tx = create_btc_spend_tx(dst_addr,
btc_txid,
btc_vout_n,
btc_contract,
spend_key=combined_btc_spend_key)
say('Sending my Bitcoin-claim transaction')
btc_claim_txid = btc_rpc.sendrawtransaction(b2x(btc_claim_tx.serialize()))
wait_confirm(say, 'Bitcoin', btc_claim_txid, die, btc_rpc, num_confirms=3)
say('Got my Bitcoin. Swap successful!')
