def get_capacity_update_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=TA(90),
other_capacity=TA(110),
reveal_timeout: int = 2,
privkey_signer: bytes = PRIVATE_KEY_1,
) -> PFSCapacityUpdate:
updatepfs_message = PFSCapacityUpdate(
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=EMPTY_SIGNATURE,
)
updatepfs_message.sign(LocalSigner(privkey_signer))
return updatepfs_message
def test_waiting_messages(pathfinding_service_mock):
participant1_privkey, participant1 = make_privkey_address()
token_network_address = TokenNetworkAddress(b"1" * 20)
channel_id = ChannelID(1)
# register token network internally
database = pathfinding_service_mock.database
database.conn.execute(
"INSERT INTO token_network(address) VALUES (?)",
[to_checksum_address(token_network_address)],
)
fee_update = PFSFeeUpdate(
canonical_identifier=CanonicalIdentifier(
chain_identifier=ChainID(1),
token_network_address=token_network_address,
channel_identifier=channel_id,
),
updating_participant=participant1,
fee_schedule=FeeScheduleState(),
timestamp=datetime.utcnow(),
signature=EMPTY_SIGNATURE,
)
fee_update.sign(LocalSigner(participant1_privkey))
capacity_update = PFSCapacityUpdate(
canonical_identifier=CanonicalIdentifier(
chain_identifier=ChainID(1),
token_network_address=token_network_address,
channel_identifier=channel_id,
),
updating_participant=make_address(),
other_participant=make_address(),
updating_nonce=Nonce(1),
other_nonce=Nonce(1),
updating_capacity=TokenAmount(100),
other_capacity=TokenAmount(111),
reveal_timeout=50,
signature=EMPTY_SIGNATURE,
)
capacity_update.sign(LocalSigner(participant1_privkey))
for message in (fee_update, capacity_update):
database.insert_waiting_message(message)
recovered_messages = list(
database.pop_waiting_messages(
token_network_address=token_network_address, channel_id=channel_id
)
)
assert len(recovered_messages) == 1
assert message == recovered_messages[0]
recovered_messages2 = list(
database.pop_waiting_messages(
token_network_address=token_network_address, channel_id=channel_id
)
)
assert len(recovered_messages2) == 0
def send_pfs_update(
raiden: "RaidenService",
canonical_identifier: CanonicalIdentifier,
update_fee_schedule: bool = False,
) -> None:
if raiden.routing_mode == RoutingMode.PRIVATE:
return
channel_state = views.get_channelstate_by_canonical_identifier(
chain_state=views.state_from_raiden(raiden), canonical_identifier=canonical_identifier
)
if channel_state is None:
return
capacity_msg = PFSCapacityUpdate.from_channel_state(channel_state)
capacity_msg.sign(raiden.signer)
raiden.transport.send_global(constants.PATH_FINDING_BROADCASTING_ROOM, capacity_msg)
log.debug("Sent a PFS Capacity Update", message=capacity_msg, channel_state=channel_state)
if update_fee_schedule:
fee_msg = PFSFeeUpdate.from_channel_state(channel_state)
fee_msg.sign(raiden.signer)
raiden.transport.send_global(constants.PATH_FINDING_BROADCASTING_ROOM, fee_msg)
log.debug("Sent a PFS Fee Update", message=fee_msg, channel_state=channel_state)
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 = PFSCapacityUpdate.from_channel_state(channel_state=channel_state)
assert message.signature == EMPTY_SIGNATURE
privkey2, address2 = factories.make_privkey_address()
signer2 = LocalSigner(privkey2)
message.sign(signer2)
assert recover(message._data_to_sign(), message.signature) == address2
assert message == DictSerializer.deserialize(DictSerializer.serialize(message))
def populate_token_network_random(token_network_model: TokenNetwork,
private_keys: List[str]) -> None:
number_of_channels = 300
# 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 = private_key_to_address(private_key1)
address2 = private_key_to_address(private_key2)
settle_timeout = BlockTimeout(15)
token_network_model.handle_channel_opened_event(
channel_identifier=channel_id,
participant1=address1,
participant2=address2,
settle_timeout=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_balance_update_message(
PFSCapacityUpdate(
canonical_identifier=CanonicalIdentifier(
chain_identifier=ChainID(61),
channel_identifier=channel_id,
token_network_address=TokenNetworkAddress(
token_network_model.address),
),
updating_participant=address1,
other_participant=address2,
updating_nonce=Nonce(1),
other_nonce=Nonce(1),
updating_capacity=deposit1,
other_capacity=deposit2,
reveal_timeout=BlockTimeout(2),
signature=EMPTY_SIGNATURE,
),
updating_capacity_partner=TokenAmount(0),
other_capacity_partner=TokenAmount(0),
)
token_network_model.handle_channel_balance_update_message(
PFSCapacityUpdate(
canonical_identifier=CanonicalIdentifier(
chain_identifier=ChainID(61),
channel_identifier=channel_id,
token_network_address=TokenNetworkAddress(
token_network_model.address),
),
updating_participant=address2,
other_participant=address1,
updating_nonce=Nonce(2),
other_nonce=Nonce(1),
updating_capacity=deposit2,
other_capacity=deposit1,
reveal_timeout=BlockTimeout(2),
signature=EMPTY_SIGNATURE,
),
updating_capacity_partner=TokenAmount(deposit1),
other_capacity_partner=TokenAmount(deposit2),
)
def populate_token_network(
token_network: TokenNetwork,
reachability_state: SimpleReachabilityContainer,
addresses: List[Address],
channel_descriptions: List,
):
for (
channel_id,
(
p1_index,
p1_capacity,
_p1_fee,
p1_reveal_timeout,
p1_reachability,
p2_index,
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_balance_update_message(
PFSCapacityUpdate(
canonical_identifier=CanonicalIdentifier(
chain_identifier=ChainID(61),
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,
signature=EMPTY_SIGNATURE,
),
updating_capacity_partner=TokenAmount(0),
other_capacity_partner=TokenAmount(0),
)
token_network.handle_channel_balance_update_message(
PFSCapacityUpdate(
canonical_identifier=CanonicalIdentifier(
chain_identifier=ChainID(61),
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,
signature=EMPTY_SIGNATURE,
),
updating_capacity_partner=TokenAmount(p1_capacity),
other_capacity_partner=TokenAmount(p2_capacity),
)
# Update presence state according to scenario
reachability_state.reachabilities[participant1] = p1_reachability
reachability_state.reachabilities[participant2] = p2_reachability
def test_encoding_and_decoding():
message_factories = (
factories.LockedTransferProperties(),
factories.RefundTransferProperties(),
factories.LockExpiredProperties(),
factories.UnlockProperties(),
)
messages = [factories.create(factory) for factory in message_factories]
# TODO Handle these with factories once #5091 is implemented
messages.append(
Delivered(
delivered_message_identifier=factories.make_message_identifier(),
signature=factories.make_signature(),
))
messages.append(
Processed(
message_identifier=factories.make_message_identifier(),
signature=factories.make_signature(),
))
messages.append(
RevealSecret(
message_identifier=factories.make_message_identifier(),
secret=factories.make_secret(),
signature=factories.make_signature(),
))
messages.append(
SecretRequest(
message_identifier=factories.make_message_identifier(),
payment_identifier=factories.make_payment_id(),
secrethash=factories.make_secret_hash(),
amount=factories.make_token_amount(),
expiration=factories.make_block_number(),
signature=factories.make_signature(),
))
messages.append(
WithdrawRequest(
message_identifier=factories.make_message_identifier(),
chain_id=factories.make_chain_id(),
token_network_address=factories.make_token_network_address(),
channel_identifier=factories.make_channel_identifier(),
participant=factories.make_address(),
total_withdraw=factories.make_token_amount(),
nonce=factories.make_nonce(),
expiration=factories.make_block_number(),
signature=factories.make_signature(),
))
messages.append(
WithdrawConfirmation(
message_identifier=factories.make_message_identifier(),
chain_id=factories.make_chain_id(),
token_network_address=factories.make_token_network_address(),
channel_identifier=factories.make_channel_identifier(),
participant=factories.make_address(),
total_withdraw=factories.make_token_amount(),
nonce=factories.make_nonce(),
expiration=factories.make_block_number(),
signature=factories.make_signature(),
))
messages.append(
WithdrawExpired(
message_identifier=factories.make_message_identifier(),
chain_id=factories.make_chain_id(),
token_network_address=factories.make_token_network_address(),
channel_identifier=factories.make_channel_identifier(),
participant=factories.make_address(),
total_withdraw=factories.make_token_amount(),
nonce=factories.make_nonce(),
expiration=factories.make_block_number(),
signature=factories.make_signature(),
))
messages.append(
PFSCapacityUpdate(
canonical_identifier=factories.make_canonical_identifier(),
updating_participant=factories.make_address(),
other_participant=factories.make_address(),
updating_nonce=factories.make_nonce(),
other_nonce=factories.make_nonce(),
updating_capacity=factories.make_token_amount(),
other_capacity=factories.make_token_amount(),
reveal_timeout=factories.make_uint64(),
signature=factories.make_signature(),
))
messages.append(
PFSFeeUpdate(
canonical_identifier=factories.make_canonical_identifier(),
updating_participant=factories.make_address(),
fee_schedule=factories.create(
factories.FeeScheduleStateProperties()),
timestamp=datetime.now(),
signature=factories.make_signature(),
))
messages.append(
RequestMonitoring(
reward_amount=factories.make_token_amount(),
balance_proof=SignedBlindedBalanceProof.
from_balance_proof_signed_state(
factories.create(
factories.BalanceProofSignedStateProperties())),
monitoring_service_contract_address=factories.make_address(),
non_closing_participant=factories.make_address(),
non_closing_signature=factories.make_signature(),
signature=factories.make_signature(),
))
for message in messages:
serialized = MessageSerializer.serialize(message)
deserialized = MessageSerializer.deserialize(serialized)
assert deserialized == message
token_network_address=factories.make_token_network_address(),
channel_identifier=factories.make_channel_identifier(),
participant=factories.make_address(),
total_withdraw=factories.make_withdraw_amount(),
nonce=factories.make_nonce(),
expiration=factories.make_block_expiration_number(),
signature=factories.make_signature(),
)
)
messages.append(
PFSCapacityUpdate(
canonical_identifier=factories.make_canonical_identifier(),
updating_participant=factories.make_address(),
other_participant=factories.make_address(),
updating_nonce=factories.make_nonce(),
other_nonce=factories.make_nonce(),
updating_capacity=factories.make_token_amount(),
other_capacity=factories.make_token_amount(),
reveal_timeout=factories.make_block_timeout(),
signature=factories.make_signature(),
)
)
messages.append(
PFSFeeUpdate(
canonical_identifier=factories.make_canonical_identifier(),
updating_participant=factories.make_address(),
fee_schedule=factories.create(factories.FeeScheduleStateProperties()),
timestamp=datetime(2000, 1, 1),
signature=factories.make_signature(),
)
)
