def get_updatepfs_message( # pylint: disable=too-many-arguments
updating_participant: Address,
other_participant: Address,
chain_identifier=ChainID(1),
channel_identifier=DEFAULT_CHANNEL_ID,
token_network_address: TokenNetworkAddress = DEFAULT_TOKEN_NETWORK_ADDRESS,
updating_nonce=Nonce(1),
other_nonce=Nonce(0),
updating_capacity=TokenAmount(90),
other_capacity=TokenAmount(110),
reveal_timeout: int = 2,
mediation_fee: FeeAmount = FeeAmount(0),
privkey_signer: bytes = PRIVATE_KEY_1,
) -> UpdatePFS:
updatepfs_message = UpdatePFS(
canonical_identifier=CanonicalIdentifier(
chain_identifier=chain_identifier,
channel_identifier=channel_identifier,
token_network_address=token_network_address,
),
updating_participant=updating_participant,
other_participant=other_participant,
updating_nonce=updating_nonce,
other_nonce=other_nonce,
updating_capacity=updating_capacity,
other_capacity=other_capacity,
reveal_timeout=reveal_timeout,
mediation_fee=mediation_fee,
signature=EMPTY_SIGNATURE,
)
updatepfs_message.sign(LocalSigner(privkey_signer))
return updatepfs_message
def get_updatepfs_message(
updating_participant: Address,
other_participant: Address,
chain_identifier=ChainID(1),
channel_identifier=ChannelID(0),
token_network_address:
TokenNetworkAddressBytes = DEFAULT_TOKEN_NETWORK_ADDRESS_BYTES,
updating_nonce=Nonce(1),
other_nonce=Nonce(0),
updating_capacity=TokenAmount(90),
other_capacity=TokenAmount(110),
reveal_timeout: int = 2,
mediation_fee: FeeAmount = FeeAmount(0),
privkey_signer: bytes = PRIVAT_KEY_EXAMPLE_1,
) -> UpdatePFS:
updatepfs_message = UpdatePFS(
canonical_identifier=CanonicalIdentifier(
chain_identifier=chain_identifier,
channel_identifier=channel_identifier,
token_network_address=token_network_address,
),
updating_participant=decode_hex(updating_participant),
other_participant=decode_hex(other_participant),
updating_nonce=updating_nonce,
other_nonce=other_nonce,
updating_capacity=updating_capacity,
other_capacity=other_capacity,
reveal_timeout=reveal_timeout,
mediation_fee=mediation_fee,
)
updatepfs_message.sign(LocalSigner(privkey_signer))
return updatepfs_message
def populate_token_network_random(token_network_model: TokenNetwork,
private_keys: List[str]) -> None:
# seed for pseudo-randomness from config constant, that changes from time to time
random.seed(NUMBER_OF_CHANNELS)
for channel_id_int in range(NUMBER_OF_CHANNELS):
channel_id = ChannelID(channel_id_int)
private_key1, private_key2 = random.sample(private_keys, 2)
address1 = Address(private_key_to_address(private_key1))
address2 = Address(private_key_to_address(private_key2))
settle_timeout = 15
token_network_model.handle_channel_opened_event(
channel_id, address1, address2, settle_timeout)
# deposit to channels
deposit1 = TokenAmount(random.randint(0, 1000))
deposit2 = TokenAmount(random.randint(0, 1000))
address1, address2 = token_network_model.channel_id_to_addresses[
channel_id]
token_network_model.handle_channel_new_deposit_event(
channel_id, address1, deposit1)
token_network_model.handle_channel_new_deposit_event(
channel_id, address2, deposit2)
token_network_model.handle_channel_balance_update_message(
UpdatePFS(
canonical_identifier=CanonicalIdentifier(
chain_identifier=ChainID(1),
channel_identifier=channel_id,
token_network_address=TokenNetworkAddressBytes(
decode_hex(token_network_model.address)),
),
updating_participant=decode_hex(address1),
other_participant=decode_hex(address2),
updating_nonce=Nonce(1),
other_nonce=Nonce(1),
updating_capacity=deposit1,
other_capacity=deposit2,
reveal_timeout=2,
mediation_fee=FeeAmount(0),
))
token_network_model.handle_channel_balance_update_message(
UpdatePFS(
canonical_identifier=CanonicalIdentifier(
chain_identifier=ChainID(1),
channel_identifier=channel_id,
token_network_address=TokenNetworkAddressBytes(
decode_hex(token_network_model.address)),
),
updating_participant=decode_hex(address2),
other_participant=decode_hex(address1),
updating_nonce=Nonce(2),
other_nonce=Nonce(1),
updating_capacity=deposit2,
other_capacity=deposit1,
reveal_timeout=2,
mediation_fee=FeeAmount(0),
))
def test_update_pfs():
properties = factories.BalanceProofSignedStateProperties(pkey=PRIVKEY)
balance_proof = factories.create(properties)
channel_state = factories.create(factories.NettingChannelStateProperties())
channel_state.our_state.balance_proof = balance_proof
channel_state.partner_state.balance_proof = balance_proof
message = UpdatePFS.from_channel_state(channel_state=channel_state)
assert message.signature == b""
privkey2, address2 = factories.make_privkey_address()
signer2 = LocalSigner(privkey2)
message.sign(signer2)
assert recover(message._data_to_sign(), message.signature) == address2
assert message == UpdatePFS.from_dict(message.to_dict())
def test_update_pfs():
balance_proof = make_balance_proof(signer=signer, amount=1)
channel_state = make_channel_state()
channel_state.our_state.balance_proof = balance_proof
channel_state.partner_state.balance_proof = balance_proof
message = UpdatePFS.from_channel_state(channel_state=channel_state)
assert message.signature == b''
privkey2, address2 = make_privkey_address()
signer2 = LocalSigner(privkey2)
message.sign(signer2)
assert recover(message._data_to_sign(), message.signature) == address2
assert message == UpdatePFS.from_dict(message.to_dict())
def get_updatepfs_message(
chain_identifier: ChainID = 1,
channel_identifier: ChannelID = 0,
token_network_address:
TokenNetworkAddress = DEFAULT_TOKEN_NETWORK_ADDRESS_BYTES,
updating_participant: Address = None,
other_participant: Address = None,
updating_nonce: Nonce = 1,
other_nonce: Nonce = 0,
updating_capacity: TokenAmount = 90,
other_capacity: TokenAmount = 110,
reveal_timeout: int = 2,
signature: Signature = '',
) -> UpdatePFS:
return UpdatePFS(
canonical_identifier=CanonicalIdentifier(
chain_identifier=chain_identifier,
channel_identifier=channel_identifier,
token_network_address=token_network_address,
),
updating_participant=updating_participant,
other_participant=other_participant,
updating_nonce=updating_nonce,
other_nonce=other_nonce,
updating_capacity=updating_capacity,
other_capacity=other_capacity,
reveal_timeout=reveal_timeout,
signature=signature,
)
def update_path_finding_service_from_balance_proof(
raiden: 'RaidenService',
chain_state: 'ChainState',
new_balance_proof: Union[BalanceProofSignedState,
BalanceProofUnsignedState],
) -> None:
channel_state = views.get_channelstate_by_canonical_identifier(
chain_state=chain_state,
canonical_identifier=new_balance_proof.canonical_identifier,
)
network_address = new_balance_proof.canonical_identifier.token_network_address
error_msg = (f'tried to send a balance proof in non-existant channel '
f'token_network_address: {pex(network_address)} ')
assert channel_state is not None, error_msg
if isinstance(new_balance_proof, BalanceProofSignedState):
assert channel_state.partner_state.balance_proof == new_balance_proof
else: # BalanceProofUnsignedState
assert channel_state.our_state.balance_proof == new_balance_proof
msg = UpdatePFS.from_channel_state(channel_state)
msg.sign(raiden.signer)
raiden.transport.send_global(constants.PATH_FINDING_BROADCASTING_ROOM, msg)
log.debug(
'Sent a PFS Update',
message=msg,
balance_proof=new_balance_proof,
)
def test_update_pfs():
balance_proof = BalanceProofUnsignedState.from_dict(
make_balance_proof(signer=signer, amount=1).to_dict(), )
message = UpdatePFS.from_balance_proof(
balance_proof=balance_proof,
reveal_timeout=1,
)
assert message.signature == b''
message.sign(signer)
assert recover(message._data_to_sign(), message.signature) == ADDRESS
def update_pfs(raiden: RaidenService, event: Event):
channel_state = get_channelstate_by_token_network_and_partner(
chain_state=state_from_raiden(raiden),
token_network_id=to_canonical_address(
event.balance_proof.token_network_identifier, ),
partner_address=to_canonical_address(event.recipient),
)
error_msg = 'tried to send a balance proof in non-existant channel '
f'token_network_address: {pex(event.balance_proof.token_network_identifier)} '
f'recipient: {pex(event.recipient)}'
assert channel_state is not None, error_msg
msg = UpdatePFS.from_balance_proof(
balance_proof=event.balance_proof,
reveal_timeout=channel_state.reveal_timeout,
)
msg.sign(raiden.signer)
raiden.transport.send_global(PATH_FINDING_BROADCASTING_ROOM, msg)
log.debug(
'sent a PFS Update',
balance_proof=event.balance_proof,
recipient=event.recipient,
)
def populate_token_network(
token_network: TokenNetwork,
address_to_reachability: Dict[Address, AddressReachability],
addresses: List[Address],
channel_descriptions: List,
):
for (
channel_id,
(
p1_index,
p1_deposit,
p1_capacity,
_p1_fee,
p1_reveal_timeout,
p1_reachability,
p2_index,
p2_deposit,
p2_capacity,
_p2_fee,
p2_reveal_timeout,
p2_reachability,
settle_timeout,
),
) in enumerate(channel_descriptions):
participant1 = addresses[p1_index]
participant2 = addresses[p2_index]
token_network.handle_channel_opened_event(
channel_identifier=ChannelID(channel_id),
participant1=participant1,
participant2=participant2,
settle_timeout=settle_timeout,
)
token_network.handle_channel_new_deposit_event(
channel_identifier=ChannelID(channel_id),
receiver=participant1,
total_deposit=p1_deposit,
)
token_network.handle_channel_new_deposit_event(
channel_identifier=ChannelID(channel_id),
receiver=participant2,
total_deposit=p2_deposit,
)
token_network.handle_channel_balance_update_message(
UpdatePFS(
canonical_identifier=CanonicalIdentifier(
chain_identifier=ChainID(1),
channel_identifier=ChannelID(channel_id),
token_network_address=TokenNetworkAddress(
token_network.address),
),
updating_participant=addresses[p1_index],
other_participant=addresses[p2_index],
updating_nonce=Nonce(1),
other_nonce=Nonce(1),
updating_capacity=p1_capacity,
other_capacity=p2_capacity,
reveal_timeout=p1_reveal_timeout,
mediation_fee=FeeAmount(0),
signature=EMPTY_SIGNATURE,
),
updating_capacity_partner=TokenAmount(0),
other_capacity_partner=TokenAmount(0),
)
token_network.handle_channel_balance_update_message(
UpdatePFS(
canonical_identifier=CanonicalIdentifier(
chain_identifier=ChainID(1),
channel_identifier=ChannelID(channel_id),
token_network_address=TokenNetworkAddress(
token_network.address),
),
updating_participant=addresses[p2_index],
other_participant=addresses[p1_index],
updating_nonce=Nonce(2),
other_nonce=Nonce(1),
updating_capacity=p2_capacity,
other_capacity=p1_capacity,
reveal_timeout=p2_reveal_timeout,
mediation_fee=FeeAmount(0),
signature=EMPTY_SIGNATURE,
),
updating_capacity_partner=TokenAmount(p1_capacity),
other_capacity_partner=TokenAmount(p2_capacity),
)
# Update presence state according to scenario
address_to_reachability[participant1] = p1_reachability
address_to_reachability[participant2] = p2_reachability
def recover_signer_from_capacity_update(message: UpdatePFS,) -> ChecksumAddress:
signer = to_checksum_address(
recover(data=message._data_to_sign(), signature=message.signature)
)
return signer
def on_pfs_update(self, message: UpdatePFS) -> None:
token_network_address = to_checksum_address(
message.canonical_identifier.token_network_address
)
updating_participant = to_checksum_address(message.updating_participant)
other_participant = to_checksum_address(message.other_participant)
# check if chain_id matches
if message.canonical_identifier.chain_identifier != self.chain_id:
raise InvalidCapacityUpdate('Received Capacity Update with unknown chain identifier')
# check if token network exists
token_network = self.get_token_network(token_network_address)
if token_network is None:
raise InvalidCapacityUpdate('Received Capacity Update with unknown token network')
# check if channel exists
channel_identifier = message.canonical_identifier.channel_identifier
if channel_identifier not in token_network.channel_id_to_addresses:
raise InvalidCapacityUpdate(
'Received Capacity Update with unknown channel identifier in token network'
)
# check values < max int 256
if message.updating_capacity > UINT256_MAX:
raise InvalidCapacityUpdate(
'Received Capacity Update with impossible updating_capacity'
)
if message.other_capacity > UINT256_MAX:
raise InvalidCapacityUpdate('Received Capacity Update with impossible other_capacity')
# check if participants fit to channel id
participants = token_network.channel_id_to_addresses[channel_identifier]
if updating_participant not in participants:
raise InvalidCapacityUpdate(
'Sender of Capacity Update does not match the internal channel'
)
if other_participant not in participants:
raise InvalidCapacityUpdate(
'Other Participant of Capacity Update does not match the internal channel'
)
# check signature of Capacity Update
signer = recover_signer_from_capacity_update(message)
if signer != updating_participant:
raise InvalidCapacityUpdate('Capacity Update not signed correctly')
# check if nonce is higher than current nonce
view_to_partner, view_from_partner = token_network.get_channel_views_for_partner(
channel_identifier=channel_identifier,
updating_participant=updating_participant,
other_participant=other_participant,
)
is_nonce_pair_known = (
message.updating_nonce <= view_to_partner.update_nonce
and message.other_nonce <= view_from_partner.update_nonce
)
if is_nonce_pair_known:
raise InvalidCapacityUpdate('Capacity Update already received')
log.info('Received Capacity Update', **message.to_dict())
token_network.handle_channel_balance_update_message(
channel_identifier=message.canonical_identifier.channel_identifier,
updating_participant=updating_participant,
other_participant=other_participant,
updating_nonce=message.updating_nonce,
other_nonce=message.other_nonce,
updating_capacity=message.updating_capacity,
other_capacity=message.other_capacity,
reveal_timeout=message.reveal_timeout,
mediation_fee=message.mediation_fee,
)
def populate_token_network(token_network: TokenNetwork,
addresses: List[Address],
channel_descriptions: List):
for (
channel_id,
(
p1_index,
p1_deposit,
p1_capacity,
_p1_fee,
p1_reveal_timeout,
p2_index,
p2_deposit,
p2_capacity,
_p2_fee,
p2_reveal_timeout,
settle_timeout,
),
) in enumerate(channel_descriptions):
token_network.handle_channel_opened_event(
ChannelID(channel_id),
addresses[p1_index],
addresses[p2_index],
settle_timeout=settle_timeout,
)
token_network.handle_channel_new_deposit_event(
ChannelID(channel_id), addresses[p1_index], p1_deposit)
token_network.handle_channel_new_deposit_event(
ChannelID(channel_id), addresses[p2_index], p2_deposit)
token_network.handle_channel_balance_update_message(
UpdatePFS(
canonical_identifier=CanonicalIdentifier(
chain_identifier=ChainID(1),
channel_identifier=ChannelID(channel_id),
token_network_address=TokenNetworkAddressBytes(
decode_hex(token_network.address)),
),
updating_participant=decode_hex(addresses[p1_index]),
other_participant=decode_hex(addresses[p2_index]),
updating_nonce=Nonce(1),
other_nonce=Nonce(1),
updating_capacity=p1_capacity,
other_capacity=p2_capacity,
reveal_timeout=p1_reveal_timeout,
mediation_fee=FeeAmount(0),
))
token_network.handle_channel_balance_update_message(
UpdatePFS(
canonical_identifier=CanonicalIdentifier(
chain_identifier=ChainID(1),
channel_identifier=ChannelID(channel_id),
token_network_address=TokenNetworkAddressBytes(
decode_hex(token_network.address)),
),
updating_participant=decode_hex(addresses[p2_index]),
other_participant=decode_hex(addresses[p1_index]),
updating_nonce=Nonce(2),
other_nonce=Nonce(1),
updating_capacity=p2_capacity,
other_capacity=p1_capacity,
reveal_timeout=p2_reveal_timeout,
mediation_fee=FeeAmount(0),
))
def on_pfs_update(self, message: UpdatePFS) -> None:
token_network = self._validate_pfs_update(message)
log.info("Received Capacity Update", **message.to_dict())
token_network.handle_channel_balance_update_message(message)