def create(cls,
wallet,
channel_name,
asset_type,
tx_nonce,
sender,
receiver,
payment,
sender_balance,
receiver_balance,
hashcode,
delay_block,
peer_commitment,
peer_hlock_commitment,
router,
next_router,
comments=None):
"""
:param wallet:
:param channel_name:
:param asset_type:
:param tx_nonce:
:param sender:
:param receiver:
:param payment:
:param sender_balance:
:param receiver_balance:
:param hashcode:
:param delay_block:
:param peer_commitment:
:param peer_hlock_commitment:
:param router:
:param next_router:
:param comments:
:return:
"""
# get nonce from latest trade
_, nonce = HtlcResponsesMessage.check_nonce(tx_nonce, channel_name)
# start to verify balance
payer_address, _, _ = uri_parser(sender)
payee_address, _, _ = uri_parser(receiver)
asset_type = asset_type.upper()
# check balance
_, payer_balance, payee_balance = HtlcResponsesMessage.check_balance(
channel_name,
asset_type,
payer_address,
sender_balance,
payee_address,
receiver_balance,
is_htcl_type=True,
payment=payment)
# 2 parts in htlc message: conclusive and inconclusive part
sign_hashcode, sign_rcode = cls.get_default_rcode()
rsmc_commitment = HtlcResponsesMessage.sign_content(
typeList=RsmcMessage._sign_type_list,
valueList=[
channel_name, nonce, payer_address, payer_balance,
payee_address, payee_balance, sign_hashcode, sign_rcode
],
privtKey=wallet._key.private_key_string)
hlock_commitment = HtlcResponsesMessage.sign_content(
start=5,
typeList=HtlcResponsesMessage._sign_type_list,
valueList=[
channel_name, payer_address, payee_address, delay_block,
int(payment), hashcode
],
privtKey=wallet._key.private_key_string)
# # ToDo: need re-sign all unconfirmed htlc message later
htlc_trade = Channel.htlc_trade(
type=EnumTradeType.TRADE_TYPE_HTLC,
role=EnumTradeRole.TRADE_ROLE_PARTNER,
asset_type=asset_type,
balance=payee_balance,
peer_balance=payer_balance,
payment=payment,
hashcode=hashcode,
delay_block=delay_block,
commitment=rsmc_commitment,
peer_commitment=peer_commitment,
delay_commitment=hlock_commitment,
peer_delay_commitment=peer_hlock_commitment,
channel=channel_name)
Channel.add_trade(channel_name, nonce=nonce, **htlc_trade)
# create message
message = HtlcResponsesMessage.create_message_header(
receiver, sender, HtlcResponsesMessage._message_name, channel_name,
asset_type, tx_nonce)
message = message.message_header
message.update({
'Router': router,
'Next': next_router,
})
message_body = {
'SenderBalance': payer_balance,
'ReceiverBalance': payee_balance,
'Commitment': rsmc_commitment,
'Payment': payment,
'DelayBlock': delay_block,
'DelayCommitment': hlock_commitment,
'HashR': hashcode
}
# orgnize the message
message.update({'MessageBody': message_body})
message.update({'Status': EnumResponseStatus.RESPONSE_OK.name})
if comments:
message.update({'Comments': comments})
# Before the response ok, we could update the channel balance
HtlcResponsesMessage.update_balance_for_channel(channel_name,
asset_type,
payer_address,
payee_address,
payment,
is_htlc_type=True)
# send response ok message to peer
HtlcResponsesMessage.send(message)
return
def create(cls,
wallet,
channel_name,
asset_type,
sender,
receiver,
payment,
hashcode,
router,
next_router,
current_channel=None,
comments=None):
"""
:param channel_name:
:param wallet:
:param sender:
:param receiver:
:param asset_type:
:param payment:
:param nonce:
:param hashcode:
:param router:
:param next_router:
:param comments:
:return:
"""
cls.check_channel_state(channel_name)
cls.check_router(router, hashcode)
cls.check_asset_type(asset_type)
cls.check_both_urls(sender, receiver)
cls.check_router(router, hashcode)
# get nonce
nonce = Channel.new_nonce(channel_name)
if HtlcMessage._FOUNDER_NONCE > nonce:
raise GoTo(
EnumResponseStatus.RESPONSE_TRADE_WITH_INCORRECT_NONCE,
'HtlcMessage::create: Incorrect nonce<{}> for channel<{}>'.
format(nonce, channel_name))
# get sender & receiver address from sender or receiver
payer_address, _, _ = uri_parser(sender)
payee_address, _, _ = uri_parser(receiver)
asset_type = asset_type.upper()
# check whether the balance is enough or not
channel = Channel(channel_name)
balance = channel.balance
_, payer_balance, payee_balance = HtlcMessage.calculate_balance_after_payment(
balance.get(payer_address, {}).get(asset_type),
balance.get(payee_address, {}).get(asset_type),
payment,
is_htlc_type=True)
# calculate the end block height
jumps_index = HtlcMessage.this_jump(sender, router)
end_block_height = cls.get_locked_block_height(len(router),
jumps_index)
# Htlc is made up of 2 parts: rsmc and hlock part
sign_hashcode, sign_rcode = cls.get_default_rcode()
rsmc_commitment = HtlcMessage.sign_content(
typeList=RsmcMessage._sign_type_list,
valueList=[
channel_name, nonce, payer_address, payer_balance,
payee_address, payee_balance, sign_hashcode, sign_rcode
],
privtKey=wallet._key.private_key_string)
# hlock parts
hlock_commitment = HtlcMessage.sign_content(
start=5,
typeList=HtlcMessage._sign_type_list,
valueList=[
channel_name, payer_address, payee_address, end_block_height,
int(payment), hashcode
],
privtKey=wallet._key.private_key_string)
# # add trade to database
htlc_trade = Channel.htlc_trade(type=EnumTradeType.TRADE_TYPE_HTLC,
role=EnumTradeRole.TRADE_ROLE_FOUNDER,
asset_type=asset_type,
balance=payer_balance,
peer_balance=payee_balance,
payment=payment,
hashcode=hashcode,
delay_block=end_block_height,
commitment=rsmc_commitment,
delay_commitment=hlock_commitment)
if current_channel:
htlc_trade.update({'channel': current_channel})
Channel.add_trade(channel_name, nonce=nonce, **htlc_trade)
# generate the messages
message_body = {
'SenderBalance': payer_balance,
'ReceiverBalance': payee_balance,
'Commitment': rsmc_commitment,
'Payment': payment,
'DelayBlock': end_block_height,
'DelayCommitment': hlock_commitment,
'HashR': hashcode
}
message = HtlcMessage.create_message_header(sender, receiver,
HtlcMessage._message_name,
channel_name, asset_type,
nonce)
message = message.message_header
message.update({
'Router': router,
'Next': next_router,
})
message.update({'MessageBody': message_body})
if comments:
message.update({'Comments': comments})
HtlcMessage.send(message)
return None
