def on_auth_received(self, nick, offer, commitment, cr, amount, kphex):
"""Receives data on proposed transaction offer from daemon, verifies
commitment, returns necessary data to send ioauth message (utxos etc)
"""
#deserialize the commitment revelation
cr_dict = PoDLE.deserialize_revelation(cr)
#check the validity of the proof of discrete log equivalence
tries = jm_single().config.getint("POLICY", "taker_utxo_retries")
def reject(msg):
jlog.info("Counterparty commitment not accepted, reason: " + msg)
return (False, )
if not verify_podle(str(cr_dict['P']),
str(cr_dict['P2']),
str(cr_dict['sig']),
str(cr_dict['e']),
str(commitment),
index_range=range(tries)):
reason = "verify_podle failed"
return reject(reason)
#finally, check that the proffered utxo is real, old enough, large enough,
#and corresponds to the pubkey
res = jm_single().bc_interface.query_utxo_set([cr_dict['utxo']],
includeconf=True)
if len(res) != 1 or not res[0]:
reason = "authorizing utxo is not valid"
return reject(reason)
age = jm_single().config.getint("POLICY", "taker_utxo_age")
if res[0]['confirms'] < age:
reason = "commitment utxo not old enough: " + str(
res[0]['confirms'])
return reject(reason)
reqd_amt = int(
amount *
jm_single().config.getint("POLICY", "taker_utxo_amtpercent") /
100.0)
if res[0]['value'] < reqd_amt:
reason = "commitment utxo too small: " + str(res[0]['value'])
return reject(reason)
if res[0]['address'] != self.wallet.pubkey_to_address(cr_dict['P']):
reason = "Invalid podle pubkey: " + str(cr_dict['P'])
return reject(reason)
# authorisation of taker passed
#Find utxos for the transaction now:
utxos, cj_addr, change_addr = self.oid_to_order(offer, amount)
if not utxos:
#could not find funds
return (False, )
self.wallet.update_cache_index()
# Construct data for auth request back to taker.
# Need to choose an input utxo pubkey to sign with
# (no longer using the coinjoin pubkey from 0.2.0)
# Just choose the first utxo in self.utxos and retrieve key from wallet.
auth_address = utxos[utxos.keys()[0]]['address']
auth_key = self.wallet.get_key_from_addr(auth_address)
auth_pub = btc.privtopub(auth_key)
btc_sig = btc.ecdsa_sign(kphex, auth_key)
return (True, utxos, auth_pub, cj_addr, change_addr, btc_sig)
def start_encryption(self, nick, maker_pk):
if nick not in self.active_orders.keys():
log.debug("Counterparty not part of this transaction. Ignoring")
return
try:
self.crypto_boxes[nick] = [
maker_pk,
as_init_encryption(self.kp, init_pubkey(maker_pk))
]
except NaclError as e:
log.debug("Unable to setup crypto box with " + nick + ": " +
repr(e))
self.msgchan.send_error(nick, "invalid nacl pubkey: " + maker_pk)
return
# send authorisation request
log.debug("Starting auth, utxos: " + pprint.pformat(self.input_utxos))
if self.auth_addr:
my_btc_addr = self.auth_addr
else:
my_btc_addr = self.input_utxos.itervalues().next()['address']
log.debug("Trying to get privkey")
my_btc_priv = self.wallet.get_key_from_addr(my_btc_addr)
log.debug("Trying to get pubkey")
my_btc_pub = btc.privtopub(my_btc_priv)
log.debug("Got pubkey: " + str(my_btc_pub))
my_btc_sig = btc.ecdsa_sign(self.kp.hex_pk(), my_btc_priv)
self.msgchan.send_auth(nick, my_btc_pub, my_btc_sig)
def on_JM_REQUEST_MSGSIG(self, nick, cmd, msg, msg_to_be_signed, hostid):
sig = btc.ecdsa_sign(str(msg_to_be_signed), self.nick_priv)
msg_to_return = str(msg) + " " + self.nick_pubkey + " " + sig
d = self.callRemote(commands.JMMsgSignature,
nick=nick,
cmd=cmd,
msg_to_return=msg_to_return,
hostid=hostid)
self.defaultCallbacks(d)
return {'accepted': True}
def auth_counterparty(self, nick, i_utxo_pubkey, btc_sig):
self.i_utxo_pubkey = i_utxo_pubkey
if not btc.ecdsa_verify(self.taker_pk, btc_sig, self.i_utxo_pubkey):
print('signature didnt match pubkey and message')
return False
# authorisation of taker passed
# (but input utxo pubkey is checked in verify_unsigned_tx).
# Send auth request to taker
# TODO the next 2 lines are a little inefficient.
btc_key = self.maker.wallet.get_key_from_addr(self.cj_addr)
btc_pub = btc.privtopub(btc_key)
btc_sig = btc.ecdsa_sign(self.kp.hex_pk(), btc_key)
self.maker.msgchan.send_ioauth(nick, self.utxos.keys(), btc_pub,
self.change_addr, btc_sig)
return True
def auth_counterparty(self, nick, i_utxo_pubkey, btc_sig):
self.i_utxo_pubkey = i_utxo_pubkey
if not btc.ecdsa_verify(self.taker_pk, btc_sig, self.i_utxo_pubkey):
print('signature didnt match pubkey and message')
return False
# authorisation of taker passed
# (but input utxo pubkey is checked in verify_unsigned_tx).
# Send auth request to taker
# TODO the next 2 lines are a little inefficient.
btc_key = self.maker.wallet.get_key_from_addr(self.cj_addr)
btc_pub = btc.privtopub(btc_key)
btc_sig = btc.ecdsa_sign(self.kp.hex_pk(), btc_key)
self.maker.msgchan.send_ioauth(nick, self.utxos.keys(), btc_pub,
self.change_addr, btc_sig)
return True
def start_encryption(self, nick, maker_pk):
if nick not in self.active_orders.keys():
log.debug("Counterparty not part of this transaction. Ignoring")
return
try:
self.crypto_boxes[nick] = [maker_pk, as_init_encryption(
self.kp, init_pubkey(maker_pk))]
except NaclError as e:
log.debug("Unable to setup crypto box with " + nick + ": " + repr(e))
self.msgchan.send_error(nick, "invalid nacl pubkey: " + maker_pk)
return
# send authorisation request
log.debug("Starting auth, utxos: " + pprint.pformat(self.input_utxos))
if self.auth_addr:
my_btc_addr = self.auth_addr
else:
my_btc_addr = self.input_utxos.itervalues().next()['address']
log.debug("Trying to get privkey")
my_btc_priv = self.wallet.get_key_from_addr(my_btc_addr)
log.debug("Trying to get pubkey")
my_btc_pub = btc.privtopub(my_btc_priv)
log.debug("Got pubkey: " + str(my_btc_pub))
my_btc_sig = btc.ecdsa_sign(self.kp.hex_pk(), my_btc_priv)
self.msgchan.send_auth(nick, my_btc_pub, my_btc_sig)
