def test_create_monitoring_request(raiden_network, token_addresses):
app0, app1 = raiden_network
token_address = token_addresses[0]
chain_state = views.state_from_app(app0)
token_network_registry_address = app0.raiden.default_registry.address
token_network_address = views.get_token_network_address_by_token_address(
chain_state=chain_state,
token_network_registry_address=token_network_registry_address,
token_address=token_address,
)
assert token_network_address
payment_identifier = create_default_identifier()
transfer(
initiator_app=app1,
target_app=app0,
token_address=token_address,
amount=PaymentAmount(1),
identifier=payment_identifier,
)
chain_state = views.state_from_raiden(app0.raiden)
channel_state = views.get_channelstate_by_token_network_and_partner(
chain_state, token_network_address, app1.raiden.address)
assert channel_state
balance_proof = cast(BalanceProofSignedState,
channel_state.partner_state.balance_proof)
api = RaidenAPI(app0.raiden)
request = api.create_monitoring_request(balance_proof=balance_proof,
reward_amount=TokenAmount(1))
assert request
as_dict = DictSerializer.serialize(request)
from_dict = DictSerializer.deserialize(as_dict)
assert DictSerializer.serialize(from_dict) == as_dict
def test_fee_update():
channel_state = factories.create(factories.NettingChannelStateProperties())
message = PFSFeeUpdate.from_channel_state(channel_state)
message.sign(signer)
assert message == DictSerializer.deserialize(
DictSerializer.serialize(message))
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 test_fee_schedule_state():
""" Don't serialize internal functions
Regression test for https://github.com/raiden-network/raiden/issues/4367
"""
state = FeeScheduleState(imbalance_penalty=[])
assert "_penalty_func" not in DictSerializer.serialize(state)
def message_from_dict(data: Dict[str, Any]) -> Message:
if "_type" not in data:
raise InvalidProtocolMessage(
"Invalid message data. Can not find the data type") from None
if data["_type"] not in VALID_MESSAGE_TYPES:
raise InvalidProtocolMessage(
'Invalid message type (data["type"] = {})'.format(
data["_type"])) from None
return DictSerializer.deserialize(data)
def restore_to_state_change(
transition_function: Callable,
storage: SerializedSQLiteStorage,
state_change_identifier: StateChangeID,
node_address: Address,
) -> Tuple[int, int, "WriteAheadLog"]:
chain_state: Optional[State]
from_identifier: StateChangeID
snapshot = storage.get_snapshot_before_state_change(
state_change_identifier=state_change_identifier)
if snapshot is not None:
log.debug(
"Restoring from snapshot",
from_state_change_id=snapshot.state_change_identifier,
to_state_change_id=state_change_identifier,
node=to_checksum_address(node_address),
)
from_identifier = snapshot.state_change_identifier
chain_state = snapshot.data
state_change_qty = snapshot.state_change_qty
else:
log.debug(
"No snapshot found, replaying all state changes",
to_state_change_id=state_change_identifier,
node=to_checksum_address(node_address),
)
from_identifier = LOW_STATECHANGE_ULID
chain_state = None
state_change_qty = 0
state_manager = StateManager(transition_function, chain_state)
wal = WriteAheadLog(state_manager, storage)
unapplied_state_changes = storage.get_statechanges_by_range(
Range(from_identifier, state_change_identifier))
if unapplied_state_changes:
log.debug(
"Replaying state changes",
replayed_state_changes=[
redact_secret(DictSerializer.serialize(state_change))
for state_change in unapplied_state_changes
],
node=to_checksum_address(node_address),
)
for state_change in unapplied_state_changes:
wal.state_manager.dispatch(state_change)
return state_change_qty, len(unapplied_state_changes), wal
def replay_state_changes(
node_address: Address,
state: State,
state_change_range: Range[StateChangeID],
storage: SerializedSQLiteStorage,
transition_function: Callable[[State, StateChange],
TransitionResult[State]],
) -> Tuple[State, int]:
unapplied_state_changes = storage.get_statechanges_by_range(
state_change_range)
log.debug(
"Replaying state changes",
replayed_state_changes=[
redact_secret(DictSerializer.serialize(state_change))
for state_change in unapplied_state_changes
],
node=to_checksum_address(node_address),
)
for state_change in unapplied_state_changes:
state, _ = dispatch(state, transition_function, state_change)
return state, len(unapplied_state_changes)
def test_request_monitoring() -> None:
properties = factories.BalanceProofSignedStateProperties(
pkey=PARTNER_PRIVKEY)
balance_proof = factories.create(properties)
partner_signed_balance_proof = SignedBlindedBalanceProof.from_balance_proof_signed_state(
balance_proof)
request_monitoring = RequestMonitoring(
balance_proof=partner_signed_balance_proof,
non_closing_participant=ADDRESS,
reward_amount=TokenAmount(55),
signature=EMPTY_SIGNATURE,
monitoring_service_contract_address=MSC_ADDRESS,
)
assert request_monitoring
request_monitoring.sign(signer)
as_dict = DictSerializer.serialize(request_monitoring)
assert DictSerializer.deserialize(as_dict) == request_monitoring
# RequestMonitoring can be created directly from BalanceProofSignedState
direct_created = RequestMonitoring.from_balance_proof_signed_state(
balance_proof=balance_proof,
non_closing_participant=ADDRESS,
reward_amount=TokenAmount(55),
monitoring_service_contract_address=MSC_ADDRESS,
)
# `direct_created` is not signed while request_monitoring is
assert DictSerializer().serialize(
direct_created) != DictSerializer().serialize(request_monitoring)
direct_created.sign(signer)
# Instances created from same balance proof are equal
assert direct_created == request_monitoring
other_balance_proof = factories.create(
factories.replace(properties, message_hash=keccak(b"2")))
other_instance = RequestMonitoring.from_balance_proof_signed_state(
balance_proof=other_balance_proof,
non_closing_participant=ADDRESS,
reward_amount=TokenAmount(55),
monitoring_service_contract_address=MSC_ADDRESS,
)
other_instance.sign(signer)
# different balance proof ==> non-equality
assert other_instance != request_monitoring
# test signature verification
assert request_monitoring.non_closing_signature
reward_proof_data = pack_reward_proof(
token_network_address=request_monitoring.balance_proof.
token_network_address,
chain_id=request_monitoring.balance_proof.chain_id,
reward_amount=request_monitoring.reward_amount,
monitoring_service_contract_address=MSC_ADDRESS,
non_closing_participant=ADDRESS,
non_closing_signature=request_monitoring.non_closing_signature,
)
assert request_monitoring.reward_proof_signature
assert recover(reward_proof_data,
request_monitoring.reward_proof_signature) == ADDRESS
blinded_data = pack_signed_balance_proof(
msg_type=MessageTypeId.BALANCE_PROOF_UPDATE,
nonce=request_monitoring.balance_proof.nonce,
balance_hash=request_monitoring.balance_proof.balance_hash,
additional_hash=request_monitoring.balance_proof.additional_hash,
canonical_identifier=factories.make_canonical_identifier(
chain_identifier=request_monitoring.balance_proof.chain_id,
token_network_address=request_monitoring.balance_proof.
token_network_address,
channel_identifier=request_monitoring.balance_proof.
channel_identifier,
),
partner_signature=request_monitoring.balance_proof.signature,
)
assert recover(blinded_data,
request_monitoring.non_closing_signature) == ADDRESS
balance_proof_data = pack_balance_proof(
nonce=request_monitoring.balance_proof.nonce,
balance_hash=request_monitoring.balance_proof.balance_hash,
additional_hash=request_monitoring.balance_proof.additional_hash,
canonical_identifier=factories.make_canonical_identifier(
chain_identifier=request_monitoring.balance_proof.chain_id,
token_network_address=request_monitoring.balance_proof.
token_network_address,
channel_identifier=request_monitoring.balance_proof.
channel_identifier,
),
)
assert (recover(
balance_proof_data,
request_monitoring.balance_proof.signature) == PARTNER_ADDRESS)
assert request_monitoring.verify_request_monitoring(
PARTNER_ADDRESS, ADDRESS)
def test_can_round_trip_serialize_locked_transfer():
locked_transfer = factories.create(
factories.LockedTransferProperties(sender=ADDRESS, pkey=PRIVKEY))
as_dict = DictSerializer.serialize(locked_transfer)
assert DictSerializer.deserialize(as_dict) == locked_transfer