def test_is_valid_balanceproof_signature():
balance_proof = factories.create(factories.BalanceProofSignedStateProperties())
valid = is_valid_balanceproof_signature(balance_proof, factories.make_address())
assert not valid, "Address does not match."
balance_proof = factories.create(
factories.BalanceProofSignedStateProperties(signature=b"\0" * 65)
)
valid = is_valid_balanceproof_signature(balance_proof, factories.make_address())
assert not valid, f"Invalid signature check: {valid.as_error_message}"
def test_is_balance_proof_usable_onchain_answer_is_false():
channel_state = factories.make_channel_set(
number_of_channels=1).channels[0]
balance_proof_wrong_channel = factories.create(
factories.BalanceProofSignedStateProperties())
is_valid_balance_proof = is_balance_proof_usable_onchain(
received_balance_proof=balance_proof_wrong_channel,
channel_state=channel_state,
sender_state=channel_state.partner_state,
)
assert is_valid_balance_proof.fail
error_message = is_valid_balance_proof.as_error_message
assert error_message.startswith(
"channel_identifier does not match. "), error_message
wrong_token_network_canonical_identifier = replace(
channel_state.canonical_identifier,
token_network_address=factories.make_address())
balance_proof_wrong_token_network = factories.create(
factories.BalanceProofSignedStateProperties(
canonical_identifier=wrong_token_network_canonical_identifier))
is_valid_balance_proof = is_balance_proof_usable_onchain(
received_balance_proof=balance_proof_wrong_token_network,
channel_state=channel_state,
sender_state=channel_state.partner_state,
)
assert is_valid_balance_proof.fail
error_message = is_valid_balance_proof.as_error_message
assert error_message.startswith(
"token_network_address does not match. "), error_message
balance_proof_overflow = factories.create(
factories.BalanceProofSignedStateProperties(
transferred_amount=factories.UINT256_MAX,
locked_amount=1,
canonical_identifier=channel_state.canonical_identifier,
))
is_valid_balance_proof = is_balance_proof_usable_onchain(
received_balance_proof=balance_proof_overflow,
channel_state=channel_state,
sender_state=channel_state.partner_state,
)
assert is_valid_balance_proof.fail
msg = is_valid_balance_proof.as_error_message
assert msg.startswith(
"Balance proof total transferred amount would overflow "), msg
assert str(factories.UINT256_MAX) in msg, msg
assert str(factories.UINT256_MAX + 1) in msg, msg
def test_balance_proof_invalid_attributes():
invalid_nonces = [-10, 0, UINT64_MAX + 1]
invalid_transferred_amounts = [-1, UINT256_MAX + 1]
invalid_locksroots = [urandom(31), urandom(33)]
invalid_signatures = [urandom(64), urandom(66)]
properties_unsigned = factories.BalanceProofProperties()
properties_signed = factories.BalanceProofSignedStateProperties(
signature=urandom(64))
for properties in (properties_unsigned, properties_signed):
for nonce in invalid_nonces:
with pytest.raises(ValueError):
factories.create(factories.replace(properties, nonce=nonce))
for amount in invalid_transferred_amounts:
with pytest.raises(ValueError):
factories.create(
factories.replace(properties, transferred_amount=amount))
for locksroot in invalid_locksroots:
with pytest.raises(ValueError):
factories.create(
factories.replace(properties, locksroot=locksroot))
for signature in invalid_signatures:
with pytest.raises(ValueError):
factories.create(
factories.replace(properties_signed, signature=signature))
def test_subdispatch_to_paymenttask_target(chain_state, netting_channel_state):
target_state = TargetTransferState(
from_hop=HopState(
node_address=netting_channel_state.partner_state.address,
channel_identifier=netting_channel_state.canonical_identifier.
channel_identifier,
),
transfer=factories.create(
factories.LockedTransferSignedStateProperties()),
secret=UNIT_SECRET,
)
subtask = TargetTask(
canonical_identifier=netting_channel_state.canonical_identifier,
target_state=target_state)
chain_state.payment_mapping.secrethashes_to_task[UNIT_SECRETHASH] = subtask
lock = factories.HashTimeLockState(amount=0,
expiration=2,
secrethash=UNIT_SECRETHASH)
netting_channel_state.partner_state.secrethashes_to_lockedlocks[
UNIT_SECRETHASH] = lock
netting_channel_state.partner_state.pending_locks = PendingLocksState(
[bytes(lock.encoded)])
state_change = Block(
block_number=chain_state.block_number,
gas_limit=GAS_LIMIT,
block_hash=chain_state.block_hash,
)
transition_result = subdispatch_to_paymenttask(chain_state=chain_state,
state_change=state_change,
secrethash=UNIT_SECRETHASH)
assert transition_result.events == []
assert transition_result.new_state == chain_state
chain_state.block_number = 20
balance_proof: BalanceProofSignedState = factories.create(
factories.BalanceProofSignedStateProperties(
canonical_identifier=netting_channel_state.canonical_identifier,
sender=netting_channel_state.partner_state.address,
transferred_amount=0,
pkey=factories.UNIT_TRANSFER_PKEY,
locksroot=LOCKSROOT_OF_NO_LOCKS,
))
state_change = ReceiveLockExpired(
balance_proof=balance_proof,
sender=netting_channel_state.partner_state.address,
secrethash=UNIT_SECRETHASH,
message_identifier=factories.make_message_identifier(),
)
transition_result = subdispatch_to_paymenttask(chain_state=chain_state,
state_change=state_change,
secrethash=UNIT_SECRETHASH)
msg = "ReceiveLockExpired should have cleared the task"
assert UNIT_SECRETHASH not in chain_state.payment_mapping.secrethashes_to_task, msg
assert len(
transition_result.events), "ReceiveLockExpired should generate events"
assert transition_result.new_state == chain_state
def test_is_balance_proof_usable_onchain_answer_is_false():
channel_state = factories.make_channel_set(
number_of_channels=1).channels[0]
balance_proof_wrong_channel = factories.create(
factories.BalanceProofSignedStateProperties())
result, msg = is_balance_proof_usable_onchain(
received_balance_proof=balance_proof_wrong_channel,
channel_state=channel_state,
sender_state=channel_state.partner_state,
)
assert result is False, result
assert msg.startswith("channel_identifier does not match. "), msg
wrong_token_network_canonical_identifier = deepcopy(
channel_state.canonical_identifier)
wrong_token_network_canonical_identifier.token_network_address = factories.make_address(
)
balance_proof_wrong_token_network = factories.create(
factories.BalanceProofSignedStateProperties(
canonical_identifier=wrong_token_network_canonical_identifier))
result, msg = is_balance_proof_usable_onchain(
received_balance_proof=balance_proof_wrong_token_network,
channel_state=channel_state,
sender_state=channel_state.partner_state,
)
assert result is False, result
assert msg.startswith("token_network_identifier does not match. "), msg
balance_proof_overflow = factories.create(
factories.BalanceProofSignedStateProperties(
transferred_amount=factories.UINT256_MAX,
locked_amount=1,
canonical_identifier=channel_state.canonical_identifier,
))
result, msg = is_balance_proof_usable_onchain(
received_balance_proof=balance_proof_overflow,
channel_state=channel_state,
sender_state=channel_state.partner_state,
)
assert result is False, result
assert msg.startswith(
"Balance proof total transferred amount would overflow "), msg
assert str(factories.UINT256_MAX) in msg, msg
assert str(factories.UINT256_MAX + 1) in msg, msg
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():
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 make_signed_balance_proof_from_counter(counter):
lock = Lock(
amount=next(counter),
expiration=next(counter),
secrethash=factories.make_secret_hash(next(counter)),
)
lock_expired_balance_proof = factories.create(
factories.BalanceProofSignedStateProperties(
nonce=next(counter),
transferred_amount=next(counter),
locked_amount=next(counter),
canonical_identifier=factories.make_canonical_identifier(
token_network_address=factories.make_address(),
channel_identifier=next(counter)),
locksroot=Locksroot(sha3(lock.as_bytes)),
message_hash=AdditionalHash(sha3(b"")),
sender=factories.HOP1,
pkey=factories.HOP1_KEY,
))
return lock_expired_balance_proof
from raiden.storage.serialization.serializer import MessageSerializer
from raiden.tests.utils import factories
from raiden.tests.utils.client import burn_eth
from raiden.tests.utils.detect_failure import expect_failure, raise_on_failure
from raiden.tests.utils.factories import HOP1, make_privkeys_ordered
from raiden.tests.utils.mocks import MockRaidenService
from raiden.tests.utils.transfer import wait_assert
from raiden.transfer import views
from raiden.transfer.identifiers import CANONICAL_IDENTIFIER_UNORDERED_QUEUE, QueueIdentifier
from raiden.transfer.state import NetworkState
from raiden.transfer.state_change import ActionChannelClose
from raiden.utils.formatting import to_checksum_address
from raiden.utils.typing import Address, Dict, List, cast
from raiden.waiting import wait_for_network_state
HOP1_BALANCE_PROOF = factories.BalanceProofSignedStateProperties(pkey=factories.HOP1_KEY)
TIMEOUT_MESSAGE_RECEIVE = 15
class MessageHandler:
def __init__(self, bag: set):
self.bag = bag
def on_messages(self, _, messages):
self.bag.update(messages)
def ping_pong_message_success(transport0, transport1):
queueid0 = QueueIdentifier(
recipient=transport0._raiden_service.address,
canonical_identifier=CANONICAL_IDENTIFIER_UNORDERED_QUEUE,
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_tamper_request_monitoring():
""" This test shows ways, how the current implementation of the RequestMonitoring's
signature scheme might be used by an attacker to tamper with the BalanceProof that is
incorporated in the RequestMonitoring message, if not all three signatures are verified."""
msc_address = bytes([1] * 20)
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,
reward_amount=55,
signature=EMPTY_SIGNATURE,
monitoring_service_contract_address=msc_address,
non_closing_participant=ADDRESS,
)
request_monitoring.sign(signer)
# This is the signature, that is supposed to authenticate the message that a monitoring
# service receives from a node. Note: It is generated on a valid Balance proof here and reused
# to authenticate invalid messages throughout the rest of the test.
exploited_signature = request_monitoring.reward_proof_signature
reward_proof_data = pack_reward_proof(
chain_id=request_monitoring.balance_proof.chain_id,
token_network_address=request_monitoring.balance_proof.
token_network_address,
reward_amount=request_monitoring.reward_amount,
monitoring_service_contract_address=msc_address,
non_closing_participant=ADDRESS,
non_closing_signature=request_monitoring.non_closing_signature,
)
# An attacker might change the balance hash
partner_signed_balance_proof.balance_hash = "tampered".encode()
tampered_balance_hash_request_monitoring = RequestMonitoring(
balance_proof=partner_signed_balance_proof,
reward_amount=55,
non_closing_participant=ADDRESS,
signature=EMPTY_SIGNATURE,
monitoring_service_contract_address=MSC_ADDRESS,
)
tampered_bp = tampered_balance_hash_request_monitoring.balance_proof
tampered_balance_hash_reward_proof_data = pack_reward_proof(
chain_id=tampered_bp.chain_id,
token_network_address=request_monitoring.balance_proof.
token_network_address,
reward_amount=tampered_balance_hash_request_monitoring.reward_amount,
monitoring_service_contract_address=msc_address,
non_closing_participant=ADDRESS,
non_closing_signature=request_monitoring.non_closing_signature,
)
# The signature works/is unaffected by that change...
recovered_address_tampered = recover(
tampered_balance_hash_reward_proof_data, exploited_signature)
assert recover(reward_proof_data,
exploited_signature) == recovered_address_tampered
assert recover(tampered_balance_hash_reward_proof_data,
exploited_signature) == ADDRESS
# ...but overall verification fails
assert not tampered_balance_hash_request_monitoring.verify_request_monitoring(
PARTNER_ADDRESS, ADDRESS)
# An attacker might change the additional_hash
partner_signed_balance_proof.additional_hash = "tampered".encode()
tampered_additional_hash_request_monitoring = RequestMonitoring(
balance_proof=partner_signed_balance_proof,
reward_amount=55,
signature=EMPTY_SIGNATURE,
monitoring_service_contract_address=MSC_ADDRESS,
non_closing_participant=ADDRESS,
)
tampered_bp = tampered_additional_hash_request_monitoring.balance_proof
tampered_additional_hash_reward_proof_data = pack_reward_proof(
chain_id=tampered_bp.chain_id,
token_network_address=(tampered_additional_hash_request_monitoring.
balance_proof.token_network_address),
reward_amount=tampered_additional_hash_request_monitoring.
reward_amount,
monitoring_service_contract_address=msc_address,
non_closing_participant=ADDRESS,
non_closing_signature=request_monitoring.non_closing_signature,
)
# The signature works/is unaffected by that change...
recovered_address_tampered = recover(
tampered_additional_hash_reward_proof_data, exploited_signature)
assert recover(reward_proof_data,
exploited_signature) == recovered_address_tampered
assert recovered_address_tampered == ADDRESS
# ...but overall verification fails
assert not tampered_balance_hash_request_monitoring.verify_request_monitoring(
PARTNER_ADDRESS, ADDRESS)
# An attacker can change the non_closing_signature
partner_signed_balance_proof.non_closing_signature = "tampered".encode()
tampered_non_closing_signature_request_monitoring = RequestMonitoring(
balance_proof=partner_signed_balance_proof,
reward_amount=55,
signature=EMPTY_SIGNATURE,
monitoring_service_contract_address=MSC_ADDRESS,
non_closing_participant=ADDRESS,
)
tampered_bp = tampered_non_closing_signature_request_monitoring.balance_proof
tampered_non_closing_signature_reward_proof_data = pack_reward_proof(
chain_id=tampered_bp.chain_id,
token_network_address=(
tampered_non_closing_signature_request_monitoring.balance_proof.
token_network_address),
reward_amount=tampered_non_closing_signature_request_monitoring.
reward_amount,
monitoring_service_contract_address=msc_address,
non_closing_participant=ADDRESS,
non_closing_signature=request_monitoring.non_closing_signature,
)
# The signature works/is unaffected by that change...
recovered_address_tampered = recover(
tampered_non_closing_signature_reward_proof_data, exploited_signature)
assert recover(reward_proof_data,
exploited_signature) == recovered_address_tampered
assert recovered_address_tampered == ADDRESS
# ...but overall verification fails
assert not tampered_non_closing_signature_request_monitoring.verify_request_monitoring(
PARTNER_ADDRESS, ADDRESS)
def test_request_monitoring():
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(
onchain_balance_proof=partner_signed_balance_proof, reward_amount=55)
assert request_monitoring
with pytest.raises(ValueError):
request_monitoring.to_dict()
request_monitoring.sign(signer)
as_dict = request_monitoring.to_dict()
assert RequestMonitoring.from_dict(as_dict) == request_monitoring
request_monitoring_packed = request_monitoring.packed()
request_monitoring.pack(request_monitoring_packed)
assert RequestMonitoring.unpack(
request_monitoring_packed) == request_monitoring
# RequestMonitoring can be created directly from BalanceProofSignedState
direct_created = RequestMonitoring.from_balance_proof_signed_state(
balance_proof, reward_amount=55)
with pytest.raises(ValueError):
# equality test uses `validated` packed format
assert direct_created == 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=sha3(b"2")))
other_instance = RequestMonitoring.from_balance_proof_signed_state(
other_balance_proof, reward_amount=55)
other_instance.sign(signer)
# different balance proof ==> non-equality
assert other_instance != request_monitoring
# test signature verification
reward_proof_data = pack_reward_proof(
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,
),
reward_amount=request_monitoring.reward_amount,
nonce=request_monitoring.balance_proof.nonce,
)
assert recover(reward_proof_data,
request_monitoring.reward_proof_signature) == ADDRESS
blinded_data = pack_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_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
def additional_args():
sender = factories.UNIT_TRANSFER_SENDER
balance_proof = factories.create(factories.BalanceProofSignedStateProperties())
return dict(sender=sender, balance_proof=balance_proof)
)
)
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(),
)
)
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_monitoring_service_address(),
non_closing_participant=factories.make_address(),
non_closing_signature=factories.make_signature(),
signature=factories.make_signature(),
)
)
@dataclass
class ClassWithGraphObject:
graph: Graph
@dataclass
