def rollback_resource(cls, channel_name, nonce, payment=None, status=None):
"""
:param channel_name:
:param nonce:
:param payment:
:return:
"""
if status is not None and status != EnumResponseStatus.RESPONSE_OK.name:
trade = Channel.query_trade(channel_name, nonce)
if trade:
Channel.delete_trade(channel_name, int(nonce))
def handle_partner_response(self):
"""
:return: response to send to peer
"""
# local variables
need_update_balance = False
# handle the resign body firstly
resign_ack = None
resign_trade = None
if self.resign_body:
resign_ack, resign_trade = self.handle_resign_body(
self.wallet, self.channel_name, self.resign_body)
# here if the peer not provide the signature, we need re-calculate the balance based on resign trade
if not (self.commitment and self.delay_commitment):
_, self.sender_balance, self.receiver_balance = self.calculate_balance_after_payment(
resign_trade.balance,
resign_trade.peer_balance,
self.payment,
is_htlc_type=True)
# to check whether the negotiated nonce is legal or not
self.validate_negotiated_nonce()
# create htlc response message
htlc_sign_body = self.response(self.sender_balance,
self.receiver_balance, self.payment,
self.hashcode, 1, self.delay_block)
# get some common local variables
sign_hashcode, sign_rcode = self.get_default_rcode()
payer_balance = int(self.sender_balance)
payee_balance = int(self.receiver_balance)
payment = int(self.payment)
# use this nonce for following message of current transaction
nonce = self.nego_nonce or self.nonce
# special case when nego-nonce is setting
if nonce != self.nonce:
# get previous record
old_trade = Channel.query_trade(self.channel_name, self.nonce)
# generate the htlc trade
htlc_trade = Channel.htlc_trade(
type=EnumTradeType.TRADE_TYPE_HTLC,
role=EnumTradeRole.TRADE_ROLE_FOUNDER,
asset_type=self.asset_type,
balance=payer_balance,
peer_balance=payee_balance,
payment=payment,
hashcode=self.hashcode,
delay_block=old_trade.delay_block,
channel=old_trade.channel)
#
# Update the trade or add new one
self.record_transaction(nonce, **htlc_trade)
# delete old one
if nonce < self.nonce:
Channel.delete_trade(self.channel_name, self.nonce)
# Get current transaction record
current_trade = Channel.query_trade(self.channel_name, nonce)
if current_trade.commitment and current_trade.delay_commitment:
# it means the htlc has already signed before.
commitment = current_trade.commitment
delay_commitment = current_trade.delay_commitment
else:
# start to sign this new transaction and save it
# check balance
self.check_balance(self.channel_name,
self.asset_type,
self.payer_address,
payer_balance,
self.payee_address,
payee_balance,
is_htcl_type=True,
payment=payment)
# sign the transaction with 2 parts: rsmc and htlc-locked part
commitment = self.sign_content(
self.wallet, RsmcMessage._sign_type_list, [
self.channel_name, nonce, self.payer_address,
payer_balance, self.payee_address, payee_balance,
sign_hashcode, sign_rcode
])
delay_commitment = self.sign_content(
self.wallet,
self._sign_type_list, [
self.channel_name, self.payer_address, self.payee_address,
int(self.delay_block),
int(payment), self.hashcode
],
start=5)
# update the transaction info
Channel.update_trade(self.channel_name,
nonce,
commitment=commitment,
delay_commitment=delay_commitment)
# peer has already sign the new transaction with nonce
if self.commitment and self.delay_commitment:
# check the signature of rsmc part
self.check_signature(self.wallet,
self.sender_address,
type_list=RsmcMessage._sign_type_list,
value_list=[
self.channel_name, nonce,
self.payer_address,
int(self.sender_balance),
self.payee_address,
int(self.receiver_balance), sign_hashcode,
sign_rcode
],
signature=self.commitment)
# check signature of htlc-lock part
self.check_signature(self.wallet,
self.sender_address,
type_list=self._sign_type_list,
value_list=[
self.channel_name, self.payer_address,
self.payee_address,
int(self.delay_block),
int(payment), self.hashcode
],
signature=self.delay_commitment)
# update this trade confirmed state
Channel.update_trade(self.channel_name,
nonce,
commitment=commitment,
delay_commitment=delay_commitment,
peer_commitment=self.commitment,
peer_delay_commitment=self.delay_commitment,
state=EnumTradeState.confirming.name)
need_update_balance = True
htlc_sign_body.update({
'Commitment': commitment,
'DelayCommitment': delay_commitment
})
# has resign response ??
if resign_ack:
htlc_sign_body.update({'ResignBody': resign_ack})
return need_update_balance, htlc_sign_body
def handle_partner_response(self):
"""
:return: response to send to peer
"""
# local variables
need_update_balance = False
is_htlc_to_rsmc = self.is_hlock_to_rsmc(self.hashcode)
# handle the resign body firstly
resign_ack = None
if self.resign_body:
resign_ack, resign_trade = self.handle_resign_body(self.wallet, self.channel_name, self.resign_body)
# here if the peer not provide the signature, we need re-calculate the balance
if not self.commitment:
_, self.sender_balance, self.receiver_balance = self.calculate_balance_after_payment(
resign_trade.balance, resign_trade.peer_balance, self.payment, is_htlc_to_rsmc
)
# to check whether the negotiated nonce is legal or not
self.validate_negotiated_nonce()
# create RSMC response message with RoleIndex==1
rsmc_sign_body = self.response(self.asset_type, self.payment, self.sender_balance, self.receiver_balance,
1, self.hashcode)
# get some common local variables
sign_hashcode, sign_rcode = self.get_rcode(self.channel_name, self.hashcode)
payer_balance = int(self.sender_balance)
payee_balance = int(self.receiver_balance)
payment = int(self.payment)
# use this nonce for following message of current transaction
nonce = self.nego_nonce or self.nonce
# if negotiated nonce by peer, delete the transaction with self.nonce
if nonce != self.nonce:
# generate the rsmc trade part
rsmc_trade = Channel.rsmc_trade(
type=EnumTradeType.TRADE_TYPE_RSMC, role=EnumTradeRole.TRADE_ROLE_FOUNDER,
asset_type=self.asset_type, balance=payer_balance, peer_balance=payee_balance, payment=payment,
hashcode=sign_hashcode, rcode=sign_rcode
)
self.record_transaction(nonce, **rsmc_trade)
if nonce < self.nonce:
Channel.delete_trade(self.channel_name, self.nonce)
# query the trade by nonce
current_trade = Channel.query_trade(self.channel_name, nonce)
if current_trade.commitment:
# It means that the transaction is already signed during resign
# previous transaction record.
commitment = current_trade.commitment
else:
# start to sign this new transaction and save it
# check balance
self.check_balance(self.channel_name, self.asset_type, self.payer_address, payer_balance,
self.payee_address, payee_balance, hlock_to_rsmc=is_htlc_to_rsmc, payment=payment)
# sign the transaction
commitment = RsmcResponsesMessage.sign_content(
self.wallet, self._sign_type_list, [self.channel_name, nonce, self.payer_address, payer_balance,
self.payee_address, payee_balance, sign_hashcode, sign_rcode]
)
# update the transaction
Channel.update_trade(self.channel_name, nonce, commitment=commitment)
# peer has already sign the new transaction with nonce
if self.commitment:
# check the signature
self.check_signature(
self.wallet, self.sender_address,
type_list=self._sign_type_list,
value_list=[self.channel_name, nonce, self.payer_address, int(self.sender_balance),
self.payee_address, int(self.receiver_balance), sign_hashcode, sign_rcode],
signature=self.commitment
)
# update this trade confirmed state
Channel.update_trade(
self.channel_name, nonce, peer_commitment=self.commitment,
state=EnumTradeState.confirmed.name
)
need_update_balance = True
rsmc_sign_body.update({'Commitment': commitment})
# has resign response ??
if resign_ack:
rsmc_sign_body.update({'ResignBody': resign_ack})
return need_update_balance, rsmc_sign_body