def get_monitor_request(self, partner_address: Address, balance_proof: BalanceProof, reward_amount: int, monitor_address: Address) -> MonitorRequest: """Get monitor request message for a given balance proof.""" monitor_request = MonitorRequest(balance_proof, reward_proof_signature=None, reward_amount=reward_amount, monitor_address=monitor_address) monitor_request.reward_proof_signature = encode_hex( sign_data(self.privkey, monitor_request.serialize_reward_proof())) non_closing_data = balance_proof.serialize_bin() + decode_hex( balance_proof.signature) monitor_request.non_closing_signature = encode_hex( sign_data(self.privkey, non_closing_data)) return monitor_request
def test_monitor_request(get_random_bp, get_random_privkey, get_random_address): balance_proof = get_random_bp() client_privkey = get_random_privkey() client_address = private_key_to_address(client_privkey) balance_proof.signature = encode_hex(sign_data(client_privkey, balance_proof.serialize_bin())) monitor_request = MonitorRequest( balance_proof, non_closing_signature=balance_proof.signature, reward_sender_address=client_address, reward_proof_signature='', reward_amount=1, monitor_address=get_random_address() ) serialized = monitor_request.serialize_data() monitor_request_verify = MonitorRequest.deserialize(serialized) balance_proof_verify = monitor_request_verify.balance_proof assert is_same_address(monitor_request_verify.monitor_address, monitor_request.monitor_address) assert is_same_address( monitor_request_verify.reward_sender_address, monitor_request.reward_sender_address ) assert monitor_request_verify.non_closing_signature == monitor_request.non_closing_signature assert monitor_request_verify.reward_amount == monitor_request.reward_amount assert is_same_address( balance_proof_verify.token_network_address, balance_proof.token_network_address ) assert balance_proof_verify.chain_id == balance_proof.chain_id assert balance_proof_verify.channel_identifier == balance_proof.channel_identifier assert balance_proof_verify.nonce == balance_proof.nonce
def test_serialize_deserialize(get_random_bp, get_random_privkey): bp = get_random_bp() privkey = get_random_privkey() bp.signature = encode_hex(sign_data(privkey, bp.serialize_bin())) serialized_message = bp.serialize_full() deserialized_message = Message.deserialize(serialized_message) assert isinstance(deserialized_message, BalanceProof)
def get_fee_info(self, partner_address: Address, **kwargs) -> FeeInfo: """Get a signed fee info message for an open channel. Parameters: partner_address - address of a partner the node has channel open with **kwargs - arguments to FeeInfo constructor """ channel_id = self.partner_to_channel_id[partner_address] fi = FeeInfo(self.contract.address, channel_id, **kwargs) fi.signature = encode_hex(sign_data(self.privkey, fi.serialize_bin())) return fi
def get_balance_proof(self, partner_address: Address, **kwargs) -> BalanceProof: """Get a signed balance proof for an open channel. Parameters: partner_address - address of a partner the node has channel open with **kwargs - arguments to BalanceProof constructor """ channel_id = self.partner_to_channel_id[partner_address] bp = BalanceProof(channel_id, self.contract.address, **kwargs) bp.signature = encode_hex(sign_data(self.privkey, bp.serialize_bin())) return bp
def request_paths(self, target_address: Address, **kwargs) -> PathsRequest: """Generate a PathsRequest for pathfinding-service . Parameters: target_address: address of the transaction target, this method is agnostic that this is verified. **kwargs: arguments to FeeInfo constructor """ # FIXME implement a nonce is necessary for replay protection request = PathsRequest(self.contract.address, target_address, **kwargs) request.signature = encode_hex( sign_data(self.privkey, request.serialize_bin())) return request
def update_transfer(self, partner_address: Address, balance_proof: BalanceProof): """Given a valid signed balance proof, this method calls `updateNonClosingBalanceProof` for an open channel """ non_closing_data = balance_proof.serialize_bin() + decode_hex( balance_proof.signature) non_closing_signature = encode_hex( sign_data(self.privkey, non_closing_data)) self.contract.functions.updateNonClosingBalanceProof( partner_address, self.address, balance_proof.balance_hash, balance_proof.nonce, balance_proof.additional_hash, balance_proof.signature, non_closing_signature).transact({'from': self.address})
def signing_update_data( balance_proof: BalanceProofSignedState, privkey: bytes, ) -> typing.Signature: update_data = pack_signing_data( balance_proof.nonce, balance_proof.balance_hash, balance_proof.message_hash, balance_proof.channel_identifier, balance_proof.token_network_identifier, balance_proof.chain_id, ) + balance_proof.signature return sign_data(encode_hex(privkey), update_data)
def signing_update_data( balance_proof: BalanceProofSignedState, chain_id: int, privkey: bytes, ) -> typing.Signature: update_data = pack_signing_data2( balance_proof.nonce, balance_proof.balance_hash, balance_proof.message_hash, balance_proof.channel_address, balance_proof.token_network_identifier, chain_id, ) + decode_hex(balance_proof.signature) return encode_hex(sign_data(privkey, update_data))
def sign2(self, private_key, node_address, chain_id): """ Creates the signature to the balance proof. Will be used in the SC refactoring. """ balance_proof = raiden_libs.messages.BalanceProof( channel_identifier=self.channel, token_network_address=self.token_network_address, balance_hash=None, nonce=self.nonce, additional_hash=self.message_hash.decode(), chain_id=chain_id, transferred_amount=self.transferred_amount, locked_amount=self.locked_amount, locksroot=self.locksroot, ) balance_proof.signature = encode_hex( sign_data(self.privkey, balance_proof.serialize_bin())) self.sender = node_address self.signature = balance_proof.signature
def sign2(self, private_key, chain_id): """ Creates the signature to the balance proof. Will be used in the SC refactoring. """ balance_hash = hash_balance_data( self.transferred_amount, self.locked_amount, self.locksroot, ) balance_proof_packed = pack_signing_data2( nonce=self.nonce, balance_hash=balance_hash, additional_hash=self.message_hash.decode(), channel_identifier=self.channel, token_network_address=self.token_network_address, chain_id=chain_id, ) self.signature = encode_hex( sign_data(self.privkey, balance_proof_packed), )