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),
)
