def handle(self): super(FounderResponsesMessage, self).handle() # check response status if not self.check_response_status(self.status): return try: # some checks and verification for founder message self.verify() self.check_nonce(self.nonce) founder_trade = Channel.query_trade(self.channel_name, self.nonce) self.check_signature(self.wallet, type_list=self._sign_type_list, value_list=[ self.channel_name, self.nonce, self.receiver_address, int(founder_trade.balance), self.sender_address, int(founder_trade.peer_balance) ], signature=self.commitment) # update the trade Channel.update_trade(self.channel_name, self.nonce, peer_commitment=self.commitment) except GoTo as error: LOG.error(error) except Exception as error: LOG.error( 'Exception occurred during creating channel<{}>. Exception: {}' .format(self.channel_name, error)) else: self.register_deposit_event()
def execute(self, block_height, invoker='', channel_name='', invoker_key=''): """ :param block_height: :param invoker_uri: :param channel_name: :param trade: :param invoker_key: :param gwei: :return: """ super(ChannelEndSettleEvent, self).execute(block_height) # close channel event result = self.contract_event_api.end_close_channel( invoker, channel_name, invoker_key, gwei_coef=self.gwei_coef) # set channel settling if result is not None and 'success' in result.values(): Channel.update_channel(self.channel_name, state=EnumChannelState.SETTLED.name) self.next_stage()
def create(sender, receiver, channel_name, asset_type, payment, nonce, comments=''): message = PaymentLinkAck.create_message_header( sender, receiver, PaymentLinkAck._message_name, channel_name, asset_type, nonce) hashcode, rcode = Payment.create_hr() Channel.add_payment(channel_name, hashcode=hashcode, rcode=rcode, payment=payment) pycode = Payment.generate_payment_code(sender, asset_type, payment, hashcode, comments) message = message.message_header message_body = {'PaymentLink': pycode} message.update({'MessageBody': message_body}) message.update({'Status': EnumResponseStatus.RESPONSE_OK.name}) if comments: message.update({'Comments': comments}) Message.send(message) pass
def prepare(self, block_height, address='', deposit=0.0, key=''): super(ChannelDepositEvent, self).prepare(block_height) # if this transaction id is approved, it means successful by eth block chain if self.approved_tx_id: checked = self.check_transaction_success(self.approved_tx_id) if checked: LOG.debug('Approved asset by address<{}:{}>'.format(address, deposit)) Channel.update_channel(self.channel_name, state=EnumChannelState.OPENING.name) LOG.info('Start to create channel<{}>. State: OPENING.'.format(self.channel_name)) console_log.info('Channel<{}> is opening'.format(self.channel_name)) # go to next stage self.next_stage() return True elif checked is False: return False else: # new transaction is pushed to chain self.approved_tx_id = None else: approved_deposit = self.contract_event_api.get_approved_asset(address) if approved_deposit >= int(deposit): LOG.debug('Has already approved: {}'.format(approved_deposit)) # go to next stage self.next_stage() return True # make transaction to chain result = self.contract_event_api.approve(address, int(deposit), key, gwei_coef=self.gwei_coef) if result: self.approved_tx_id = '0x'+result.strip() return False
def execute(self, block_height, invoker='', channel_name='', hashcode='', invoker_key=''): """ :param block_height: :param invoker: :param channel_name: :param hashcode: :param invoker_key: :return: """ super(ChannelSettleHtlcUnlockEvent, self).execute(block_height) # close channel event result = self.contract_event_api.settle_after_htlc_unlock_payment( invoker_key, channel_name, hashcode, invoker_key) # set channel settling if result is not None and 'success' in result.values(): Channel.update_channel(self.channel_name, state=EnumChannelState.SETTLED.name) self.next_stage()
def validate_transaction(self): """ :return: """ # check the trade with nonce existed or not try: pre_trade = Channel.query_trade(self.channel_name, self.nonce - 1) except Exception as error: # should never go here raise ( EnumResponseStatus.RESPONSE_TRADE_NOT_FOUND, 'Transaction with nonce<{}> is not found'.format(self.nonce - 1)) else: if pre_trade.state in [ EnumTradeState.confirmed.name or EnumTradeState.confirmed_onchain.name ]: return True elif pre_trade.state in [EnumTradeState.confirming.name] \ and EnumTradeType.TRADE_TYPE_HTLC.name == pre_trade.type \ and pre_trade.peer_commitment and pre_trade.peer_delay_commitment: return True raise GoTo( EnumResponseStatus. RESPONSE_TRADE_RESIGN_REQUEST_NOT_IMPLEMENTED, 'Wait for next resign. current confirmed nonce<{}>, request nonce<{}>' .format(Channel.latest_confirmed_nonce(), self.nonce))
def check_nonce(cls, nonce, channel_name='', is_founder=False): """ :param channel_name: :param nonce: :return: """ nonce = int(nonce) nego_trade = Channel.query_trade(channel_name, nonce) pre_trade = Channel.query_trade(channel_name, nonce - 1) # to check whether the nonce is legal one or not if not (TransactionBase._FOUNDER_NONCE < nonce and pre_trade.state in [ EnumTradeState.confirmed.name, EnumTradeState.confirmed_onchain.name ] and ( (nego_trade.state in [EnumTradeState.init.state] and is_founder) or (nego_trade.state in [EnumTradeState.confirming.state] and not is_founder))): raise GoTo( EnumResponseStatus.RESPONSE_TRADE_WITH_INCOMPATIBLE_NONCE, '{}::Channel<{}> has incompatible nonce<{}>, state<previous:{}, negotiated: {}>' \ .format(cls.__name__, channel_name, nonce, pre_trade.state, nego_trade.state)) else: return True, nego_trade
def execute(self, block_height, channel_name='', hashcode=''): """ :param block_height: :param channel_name: :param kwargs: :return: """ super(ChannelHtlcUnlockedEvent, self).execute(block_height) # if monitor this event, update the htlc trade state to confirmed if channel_name and hashcode: try: htlc_trade = Channel.batch_query_trade( channel_name, filters={ 'type': EnumTradeType.TRADE_TYPE_HTLC.name, 'hashcode': hashcode })[0] except Exception as error: LOG.error('Htlc trade with HashR<{}> not found for channel<{}>. Exception: {}'\ .format(hashcode, channel_name, error)) else: Channel.update_trade( channel_name, htlc_trade.nonce, state=EnumTradeState.confirmed_onchain.name) else: LOG.error( 'Error input parameters: channel <{}>, hashcode<{}>.'.format( channel_name, hashcode))
def notify_rcode_to_next_peer(self, next_channel): """ :param next_channel: :return: """ peer = None try: # original payer is found if not next_channel: LOG.info('HTLC Founder with HashR<{}> received the R-code<{}>'. format(self.hashcode, self.rcode)) return htlc_trade = self.get_htlc_trade_by_hashr(next_channel, self.hashcode) if next_channel != htlc_trade.channel: LOG.error('Why the channel is different. next_channel<{}>, stored channel<{}>' \ .format(next_channel, htlc_trade.channel)) # notify the previous node the R-code LOG.debug('Payment get channel {}/{}'.format( next_channel, self.hashcode)) channel = Channel(next_channel) peer = channel.peer_uri(self.wallet.url) nonce = channel.latest_nonce(next_channel) LOG.info("Next peer: {}".format(peer)) self.create(next_channel, self.asset_type, nonce, self.wallet.url, peer, self.hashcode, self.rcode, self.comments) except Exception as error: LOG.error('Failed to notify RCode<{}> to peer<{}>'.format( self.rcode, peer))
def error_handler(self, block_height, *args, **kwargs): super(ChannelQuickSettleEvent, self).error_handler(block_height, *args, **kwargs) # if running here, it means the channel is still OPENED total_deposit = self.contract_event_api.get_channel_total_balance(self.channel_name) if 0 < total_deposit: Channel.update_channel(self.channel_name, state=EnumChannelState.OPENED.name) sync_channel_info_to_gateway(self.channel_name, 'AddChannel', self.asset_type)
def create(wallet, receiver, channel_name, asset_type): """ :param channel_name: :param wallet: :param sender: :param receiver: :param asset_type: :return: """ sender = wallet.url channel = Channel(channel_name) nonce = SettleMessage._SETTLE_NONCE asset_type = asset_type.upper() sender_address, _, _, = uri_parser(sender) receiver_address, _, _, = uri_parser(receiver) balance = channel.balance sender_balance = balance.get(sender_address, {}).get(asset_type) receiver_balance = balance.get(receiver_address, {}).get(asset_type) commitment = SettleMessage.sign_content( typeList=SettleMessage._sign_type_list, valueList=[ channel_name, nonce, sender_address, int(sender_balance), receiver_address, int(receiver_balance) ], privtKey=wallet._key.private_key_string) # add trade to database settle_trade = Channel.settle_trade( type=EnumTradeType.TRADE_TYPE_QIUCK_SETTLE, role=EnumTradeRole.TRADE_ROLE_FOUNDER, asset_type=asset_type, balance=sender_balance, peer_balance=receiver_balance, commitment=commitment) SettleMessage.add_or_update_quick_settle_trade( channel_name, EnumTradeRole.TRADE_ROLE_FOUNDER, **settle_trade) # create settle request message message = SettleMessage.create_message_header( sender, receiver, SettleMessage._message_name, channel_name, asset_type, nonce) message = message.message_header message_body = { "Commitment": commitment, "SenderBalance": sender_balance, "ReceiverBalance": receiver_balance } message.update({'MessageBody': message_body}) Message.send(message) return
def handle(self): super(RsmcResponsesMessage, self).handle() status = EnumResponseStatus.RESPONSE_OK try: # check the response status if not self.check_response_status(self.status): self.rollback_resource(self.channel_name, self.nonce, self.payment, self.status) return # common check self.check_channel_state(self.channel_name) self.verify() self.check_role(self.role_index) if 0 == self.role_index: need_update_balance, rsmc_sign_body = self.handle_partner_response() elif 1 == self.role_index: need_update_balance, rsmc_sign_body = self.handle_founder_response() else: raise GoTo(EnumResponseStatus.RESPONSE_FAIL, 'Invalid Role<{}> of RsmcResponse'.format(self.role_index)) # send RsmcSign to peer if rsmc_sign_body: response_message = self.create_message_header(self.receiver, self.sender, self._message_name, self.channel_name, self.asset_type, self.nego_nonce or self.nonce) response_message.update({'MessageBody': rsmc_sign_body}) response_message.update({'Status': status.name}) self.send(response_message) is_htlc_to_rsmc = self.is_hlock_to_rsmc(self.hashcode) if is_htlc_to_rsmc: # update the htlc transaction state. Channel.confirm_payment(self.channel_name, self.hashcode, is_htlc_to_rsmc) # update the channel balance if need_update_balance: APIStatistics.update_statistics(self.wallet.address, payment=self.payment, payer=(0==self.role_index)) self.update_balance_for_channel(self.channel_name, self.asset_type, self.payer_address, self.payee_address, self.payment, is_htlc_to_rsmc) except GoTo as error: LOG.exception(error) status = error.reason except Exception as error: status = EnumResponseStatus.RESPONSE_EXCEPTION_HAPPENED LOG.exception('Failed to handle RsmcSign for channel<{}> nonce<{}>, role_index<{}>.Exception: {}' \ .format(self.channel_name, self.nonce, self.role_index, error)) finally: # send error response if EnumResponseStatus.RESPONSE_OK != status: if 0 == self.role_index: self.send_error_response(self.sender, self.receiver, self.channel_name, self.asset_type, self.nonce, status, kwargs={'RoleIndex': '1'}) # need rollback some resources self.rollback_resource(self.channel_name, self.nonce, self.payment, status=self.status) return
def terminate(self, block_height, *args, asset_type='TNC'): super(ChannelQuickSettleEvent, self).terminate(block_height) # to check the total deposit of the channel total_deposit = self.contract_event_api.get_channel_total_balance(self.channel_name) if 0 >= total_deposit: Channel.update_channel(self.channel_name, state=EnumChannelState.CLOSED.name) APIStatistics.update_statistics(self.wallet_address, state=EnumChannelState.CLOSED.name) console_log.info('Channel {} state is {}'.format(self.channel_name, EnumChannelState.CLOSED.name)) self.next_stage()
def handle_founder_response(self): """ :return: """ need_update_balance = False # handle the resign body firstly if self.resign_body: resign_ack, _ = self.handle_resign_body(self.wallet, self.channel_name, self.resign_body) sign_hashcode, sign_rcode = self.get_rcode(self.channel_name, self.hashcode) # has already signed by peer 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, self.nonce, self.payer_address, int(self.sender_balance), self.payee_address, int(self.receiver_balance), sign_hashcode, sign_rcode], signature=self.commitment ) # Just update current transaction confirmed: Channel.update_trade(self.channel_name, self.nonce, peer_commitment=self.commitment, state=EnumTradeState.confirmed.name) need_update_balance = True if self.comments: self.notify_peer_payment_finished() else: # to check the latest confirmed nonce self.validate_transaction() # if running here, it means that the transaction has been succeeded to resign is_htlc_to_rsmc = self.is_hlock_to_rsmc(self.hashcode) self.check_balance(self.channel_name, self.asset_type, self.payer_address, self.sender_balance, self.payee_address, self.receiver_balance, hlock_to_rsmc=is_htlc_to_rsmc, payment=self.payment) # sign this transaction commitment = RsmcResponsesMessage.sign_content( self.wallet, self._sign_type_list, [self.channel_name, self.nonce, self.payer_address, int(self.sender_balance), self.payee_address, int(self.receiver_balance), sign_hashcode, sign_rcode] ) # update the transaction confirming state Channel.update_trade(self.channel_name, self.nonce, balance=self.receiver_balance, peer_balance=self.sender_balance, commitment=commitment, state=EnumTradeState.confirming.name) rsmc_sign_body = self.response(self.asset_type, self.payment, self.sender_balance, self.receiver_balance, 0, self.hashcode) rsmc_sign_body.update({'Commitment': commitment}) return need_update_balance, rsmc_sign_body return need_update_balance, None
def prepare(self, block_height, *args, **kwargs): super(ChannelQuickSettleEvent, self).prepare(block_height, *args, **kwargs) # update the channel OPENING State after trigger the deposit event, wait for OPENED if self.retry is False: Channel.update_channel(self.channel_name, state=EnumChannelState.CLOSING.name) LOG.info('Start to quick-close channel<{}>. State: CLOSING.'.format(self.channel_name)) console_log.info('Channel<{}> is closing'.format(self.channel_name)) # go to next stage self.next_stage()
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(self): super(RResponse, self).handle() status = EnumResponseStatus.RESPONSE_OK try: self.check_channel_state(self.channel_name) self.check_rcode(self.hashcode, self.rcode) htlc_trade = self.get_htlc_trade_by_hashr(self.channel_name, self.hashcode) Channel.update_trade(self.channel_name, htlc_trade.nonce, rcode=self.rcode) # check payment: stored_payment = int(htlc_trade.payment) if stored_payment != self.payment: raise GoTo( EnumResponseStatus.RESPONSE_TRADE_UNMATCHED_PAYMENT, 'Unmatched payment. self stored payment<{}>, peer payment<{}>' .format(stored_payment, self.payment)) # send response OK message RResponseAck.create(self.channel_name, self.asset_type, self.nonce, self.sender, self.receiver, self.hashcode, self.rcode, self.payment, self.comments, status) except TrinityException as error: LOG.error(error) status = error.reason except Exception as error: status = EnumResponseStatus.RESPONSE_EXCEPTION_HAPPENED LOG.error( 'Failed to handle RResponse with HashR<{}>. Exception: {}'. format(self.hashcode, error)) pass else: # trigger rsmc self.trigger_pay_by_rsmc() # notify rcode to next peer LOG.debug( 'notify the RResponse to next channel<{}>, current channel<{}>' .format(htlc_trade.channel, self.channel_name)) self.notify_rcode_to_next_peer(htlc_trade.channel) finally: if EnumResponseStatus.RESPONSE_OK != status: RResponseAck.send_error_response(self.sender, self.receiver, self.channel_name, self.asset_type, self.nonce, status) return None
def execute(self, block_height, channel_name='', **kwargs): """ :param block_height: :param channel_name: :param kwargs: :return: """ super(ChannelSettledEvent, self).execute(block_height) # if monitor this event, close channel directly if channel_name: Channel.update_channel(channel_name, state=EnumChannelState.SETTLED.name)
def register_quick_close_event(self, is_founder=True): """ :param is_founder: :return: """ try: channel_event = ChannelQuickSettleEvent(self.channel_name, is_founder) if is_founder: settle_trade = Channel.query_trade(self.channel_name, SettleBase._SETTLE_NONCE) # register arguments for execution action channel_event.register_args( EnumEventAction.EVENT_EXECUTE, self.receiver_address, self.channel_name, self.nonce, self.receiver_address, settle_trade.balance, self.sender_address, settle_trade.peer_balance, settle_trade.commitment, self.commitment, self.wallet._key.private_key_string) # register arguments for termination action channel_event.register_args(EnumEventAction.EVENT_TERMINATE, asset_type=self.asset_type) except Exception as error: LOG.error( 'Failed to regiser quick close channel event since {}'.format( error)) else: # register and trigger the event event_machine.register_event(self.channel_name, channel_event) event_machine.trigger_start_event(self.channel_name)
def channel_close(self, arguments): """ :param arguments: :return: """ channel_name = get_arg(arguments, 1) console_log.console("Closing channel {}".format(channel_name)) if channel_name: Channel.quick_close(channel_name, wallet=self.Wallet, cli=True, trigger=SettleMessage.create) else: console_log.warn("No Channel Create")
def create(wallet, channel_name, asset_type, nonce, sender, sender_balance, receiver, receiver_balance, peer_commitment, comments=None): """ :param wallet: :param channel_name: :param asset_type: :param sender: :param receiver: :param sender_balance: :param receiver_balance: :param peer_commitment: :param status: :return: """ sender_address, _, _ = uri_parser(sender) receiver_address, _, _ = uri_parser(receiver) asset_type = asset_type.upper() # sign the contents commitment = SettleResponseMessage.sign_content( wallet, SettleResponseMessage._sign_type_list, [ channel_name, nonce, sender_address, int(sender_balance), receiver_address, int(receiver_balance) ]) # finally, add the transaction information to database settle_trade = Channel.settle_trade( type=EnumTradeType.TRADE_TYPE_QIUCK_SETTLE, role=EnumTradeRole.TRADE_ROLE_PARTNER, asset_type=asset_type, balance=receiver_balance, peer_balance=sender_balance, commitment=commitment, peer_commitment=peer_commitment) SettleResponseMessage.add_or_update_quick_settle_trade( channel_name, EnumTradeRole.TRADE_ROLE_PARTNER, **settle_trade) message = SettleResponseMessage.create_message_header( receiver, sender, SettleResponseMessage._message_name, channel_name, asset_type, nonce) message.update({"MessageBody": {"Commitment": commitment}}) if not comments: message.update({'Comments': comments}) # send response OK message message.update({'Status': EnumResponseStatus.RESPONSE_OK.name}) Message.send(message)
def check_channel_state(cls, channel_name): channel = Channel(channel_name) if not channel.is_opened: raise GoTo( EnumResponseStatus.RESPONSE_CHANNEL_NOT_OPENED, 'Channel is not OPENED. Current tate<{}>'.format( channel.state)) return channel
def register_deposit_event(self, is_founder=True): """ :param is_founder: :return: """ try: channel_event = ChannelDepositEvent(self.channel_name, self.wallet.address, is_founder) # get the transaction record of founder message founder_trade = Channel.query_trade(self.channel_name, FounderBase._FOUNDER_NONCE) # set some arguments by the role type self_address = self.receiver_address self_deposit = founder_trade.balance if is_founder: founder_address = self.receiver_address founder_deposit = founder_trade.balance founder_commitment = founder_trade.commitment partner_address = self.sender_address partner_deposit = founder_trade.peer_balance partner_commitment = founder_trade.peer_commitment else: founder_address = self.sender_address founder_deposit = founder_trade.peer_balance founder_commitment = founder_trade.peer_commitment partner_address = self.receiver_address partner_deposit = founder_trade.balance partner_commitment = founder_trade.commitment # register the preparation action for deposit event channel_event.register_args(EnumEventAction.EVENT_PREPARE, self_address, self_deposit, self.wallet._key.private_key_string) # add execution action for deposit event channel_event.register_args( EnumEventAction.EVENT_EXECUTE, self_address, self.channel_name, FounderBase._FOUNDER_NONCE, founder_address, founder_deposit, partner_address, partner_deposit, founder_commitment, partner_commitment, self.wallet._key.private_key_string) channel_event.register_args(EnumEventAction.EVENT_TERMINATE, asset_type=self.asset_type) except Exception as error: LOG.exception( 'Failed to register deposit event since {}'.format(error)) else: # register and trigger event event_machine.register_event(self.channel_name, channel_event) event_machine.trigger_start_event(self.channel_name) return
def channel_payment(self, arguments): """ :param arguments: :return: """ asset_type = get_arg(arguments, 1) if not check_support_asset_type(asset_type): console_log.error( "No support asset, current just support {}".format( SupportAssetType.SupportAssetType)) return None value = TrinityNumber(get_arg(arguments, 2).strip()).number if not value: console_log.error("command not give the count") return None try: if 0 >= value or not check_float_decimals(value, asset_type): console_log.error("value should not be less than 0") return None except ValueError: console_log.error("value format error") return None comments = " ".join(arguments[3:]) comments = comments if comments else "None" if len(comments) > 128: console_log.error("comments length should be less than 128") return None try: hash_r, rcode = Payment.create_hr() Channel.add_payment(None, hash_r, rcode, value) paycode = Payment.generate_payment_code(self.Wallet.url, asset_type, value, hash_r, comments, True) except Exception as e: LOG.error(e) console_log.error("Get payment link error, please check the log") return None if self.qrcode: qrcode_terminal.draw(paycode, version=4) console_log.console(paycode) return None
def check_payment(cls, channel_name, address, asset_type, payment): """ :param channel_name: :param address: :param asset_type: :param payment: :return: """ channel_balance = Channel(channel_name).balance balance = channel_balance.get(address).get(asset_type.upper()) if not 0 < int(payment) <= int(balance): raise GoTo( EnumResponseStatus. RESPONSE_TRADE_NO_ENOUGH_BALANCE_FOR_PAYMENT, 'Invalid payment<{}>, payer balance<{}>'.format( payment, balance)) return True, int(balance)
def check_hashcode_used(cls, channel_name, hashcode): try: trade_record = Channel.batch_query_trade( channel_name, filters={'hashcode': hashcode})[0] except Exception as error: return True else: raise GoTo( EnumResponseStatus.RESPONSE_TRADE_HASHR_ALREADY_EXISTED, 'HashR<{}> already used by trade with nonce<{}>'.format( hashcode, trade_record.nonce))
def record_transaction(self, nonce, **update_args): """ :param nonce: :param update_args: :return: """ # check the trade with nonce existed or not try: new_trade = Channel.query_trade(self.channel_name, nonce) except Exception as error: new_trade = None # add new transaction if new_trade: Channel.update_trade(self.channel_name, nonce=nonce, **update_args) else: Channel.add_trade(self.channel_name, nonce=nonce, **update_args) return
def terminate(self, block_height, *args, asset_type='TNC'): super(ChannelDepositEvent, self).terminate(block_height, *args) # check the deposit of the contract address total_deposit = self.contract_event_api.get_channel_total_balance(self.channel_name) if total_deposit >= self.deposit + self.partner_deposit: Channel.update_channel(self.channel_name, state=EnumChannelState.OPENED.name) Channel.update_trade(self.channel_name, self.nonce, state=EnumTradeState.confirmed.name) sync_channel_info_to_gateway(self.channel_name, 'AddChannel', asset_type) console_log.info('Channel {} state is {}'.format(self.channel_name, EnumChannelState.OPENED.name)) # to trigger monitor event for closing channel event_monitor_close_channel(self.channel_name) event_monitor_settle(self.channel_name) # to trigger monitor event for unlocking htlc locked payment event_monitor_withdraw(self.channel_name) event_monitor_withdraw_update(self.channel_name) event_monitor_withdraw_settle(self.channel_name) self.next_stage()
def notify_peer_payment_finished(self,): try: payment_record = Channel.query_payment(self.channel_name, self.comments)[0] receiver = payment_record.receiver except: LOG.warning('No payment record with code<{}> is found'.format(self.comments)) pass else: PaymentAck.create(self.wallet.url, receiver, self.channel_name, self.asset_type, self.nonce, self.comments) return
def execute(self, block_height, invoker_uri='', channel_name='', invoker_key='', nonce=None): """ :param block_height: :param invoker_uri: :param channel_name: :param trade: :param invoker_key: :param gwei: :return: """ super(ChannelUpdateSettleEvent, self).execute(block_height) # close channel event # ToDo uncomment below codes in future # latest_trade = Channel.latest_confirmed_trade() # if isinstance(nonce, int) and int(nonce) == latest_trade.nonce: # or check balance: # self.next_stage() # return result = Channel.force_release_rsmc( invoker_uri, channel_name, nonce, invoker_key, gwei_coef=self.gwei_coef, trigger=self.contract_event_api.update_close_channel) # set channel settling if result is not None and 'success' in result.values(): Channel.update_channel(self.channel_name, state=EnumChannelState.SETTLED.name) APIStatistics.update_statistics( self.wallet_address, state=EnumChannelState.SETTLED.name) self.next_stage()