def test_events_loaded_from_storage_should_deserialize(tmp_path):
filename = f"{tmp_path}/v{RAIDEN_DB_VERSION}_log.db"
storage = SerializedSQLiteStorage(filename, serializer=JSONSerializer())
# Satisfy the foreign-key constraint for state change ID
ids = storage.write_state_changes([
ActionInitChain(
pseudo_random_generator=random.Random(),
block_number=1,
block_hash=b"",
our_address=factories.make_address(),
chain_id=1,
)
])
canonical_identifier = factories.make_canonical_identifier()
recipient = factories.make_address()
participant = factories.make_address()
event = SendWithdrawRequest(
recipient=recipient,
canonical_identifier=canonical_identifier,
message_identifier=factories.make_message_identifier(),
total_withdraw=1,
participant=participant,
expiration=10,
nonce=15,
)
storage.write_events([(ids[0], event)])
stored_events = storage.get_events()
assert stored_events[0] == event
def test_events_loaded_from_storage_should_deserialize(tmp_path):
filename = Path(f"{tmp_path}/v{RAIDEN_DB_VERSION}_log.db")
storage = SerializedSQLiteStorage(filename, serializer=JSONSerializer())
# Satisfy the foreign-key constraint for state change ID
ids = storage.write_state_changes([
Block(
block_number=BlockNumber(1),
gas_limit=BlockGasLimit(1),
block_hash=factories.make_block_hash(),
)
])
canonical_identifier = factories.make_canonical_identifier()
recipient = factories.make_address()
participant = factories.make_address()
event = SendWithdrawRequest(
recipient=recipient,
canonical_identifier=canonical_identifier,
message_identifier=factories.make_message_identifier(),
total_withdraw=WithdrawAmount(1),
participant=participant,
expiration=BlockExpiration(10),
nonce=Nonce(15),
)
storage.write_events([(ids[0], event)])
stored_events = storage.get_events()
assert stored_events[0] == event
def test_channel_closed_must_clear_ordered_messages(chain_state,
token_network_state,
netting_channel_state):
recipient = netting_channel_state.partner_state.address
channel_identifier = netting_channel_state.identifier
message_identifier = random.randint(0, 2**16)
amount = 10
queue_identifier = QueueIdentifier(recipient, channel_identifier)
# Regression test:
# The code delivered_message handler worked only with a queue of one
# element
message = factories.create(
factories.LockedTransferProperties(
message_identifier=message_identifier,
token=token_network_state.token_address,
canonical_identifier=factories.make_canonical_identifier(
channel_identifier=channel_identifier),
transferred_amount=amount,
recipient=recipient,
))
chain_state.queueids_to_queues[queue_identifier] = [message]
closed = state_change.ContractReceiveChannelClosed(
transaction_hash=EMPTY_HASH,
transaction_from=recipient,
canonical_identifier=netting_channel_state.canonical_identifier,
block_number=1,
block_hash=factories.make_block_hash(),
)
iteration = node.handle_state_change(chain_state, closed)
assert queue_identifier not in iteration.new_state.queueids_to_queues
def run_test_receive_secrethashtransfer_unknown(raiden_network,
token_addresses):
app0 = raiden_network[0]
token_address = token_addresses[0]
token_network_identifier = views.get_token_network_identifier_by_token_address(
views.state_from_app(app0), app0.raiden.default_registry.address,
token_address)
other_key = HOP1_KEY
other_signer = LocalSigner(other_key)
canonical_identifier = factories.make_canonical_identifier(
token_network_address=token_network_identifier)
amount = 10
refund_transfer_message = factories.create(
factories.RefundTransferProperties(
payment_identifier=1,
nonce=1,
token=token_address,
canonical_identifier=canonical_identifier,
transferred_amount=amount,
recipient=app0.raiden.address,
locksroot=UNIT_SECRETHASH,
amount=amount,
secret=UNIT_SECRET,
))
sign_and_inject(refund_transfer_message, other_signer, app0)
unlock = Unlock(
chain_id=UNIT_CHAIN_ID,
message_identifier=random.randint(0, UINT64_MAX),
payment_identifier=1,
nonce=1,
channel_identifier=canonical_identifier.channel_identifier,
token_network_address=token_network_identifier,
transferred_amount=amount,
locked_amount=0,
locksroot=UNIT_SECRETHASH,
secret=UNIT_SECRET,
)
sign_and_inject(unlock, other_signer, app0)
secret_request_message = SecretRequest(
message_identifier=random.randint(0, UINT64_MAX),
payment_identifier=1,
secrethash=UNIT_SECRETHASH,
amount=1,
expiration=refund_transfer_message.lock.expiration,
)
sign_and_inject(secret_request_message, other_signer, app0)
reveal_secret_message = RevealSecret(message_identifier=random.randint(
0, UINT64_MAX),
secret=UNIT_SECRET)
sign_and_inject(reveal_secret_message, other_signer, app0)
def channel_properties(our_address, token_network_state):
partner_privkey, address = factories.make_privkey_address()
properties = factories.NettingChannelStateProperties(
our_state=factories.NettingChannelEndStateProperties(balance=80, address=our_address),
partner_state=factories.NettingChannelEndStateProperties(balance=80, address=address),
canonical_identifier=factories.make_canonical_identifier(
token_network_address=token_network_state.address
),
)
return properties, partner_privkey
def run_test_mediated_transfer_calls_pfs(raiden_network, token_addresses):
app0, = raiden_network
token_address = token_addresses[0]
chain_state = views.state_from_app(app0)
payment_network_id = app0.raiden.default_registry.address
token_network_id = views.get_token_network_identifier_by_token_address(
chain_state, payment_network_id, token_address)
with patch("raiden.routing.query_paths",
return_value=([], None)) as patched:
app0.raiden.start_mediated_transfer_with_secret(
token_network_identifier=token_network_id,
amount=10,
fee=0,
target=factories.HOP1,
identifier=1,
payment_hash_invoice=EMPTY_PAYMENT_HASH_INVOICE,
secret=b"1" * 32,
)
assert not patched.called
config_patch = dict(
pathfinding_service_address="mock-address",
pathfinding_eth_address=factories.make_checksum_address(),
)
with patch.dict(app0.raiden.config["services"], config_patch):
app0.raiden.start_mediated_transfer_with_secret(
token_network_identifier=token_network_id,
amount=11,
fee=0,
target=factories.HOP2,
identifier=2,
payment_hash_invoice=EMPTY_PAYMENT_HASH_INVOICE,
secret=b"2" * 32,
)
assert patched.call_count == 1
locked_transfer = factories.create(
factories.LockedTransferProperties(
amount=TokenAmount(5),
initiator=factories.HOP1,
target=factories.HOP2,
sender=factories.HOP1,
pkey=factories.HOP1_KEY,
token=token_address,
canonical_identifier=factories.make_canonical_identifier(
token_network_address=token_network_id),
))
app0.raiden.mediate_mediated_transfer(locked_transfer)
assert patched.call_count == 2
def test_send_refund_transfer_contains_balance_proof():
recipient = factories.make_address()
transfer = factories.create(factories.LockedTransferUnsignedStateProperties())
message_identifier = 1
event = SendRefundTransfer(
recipient=recipient,
message_identifier=message_identifier,
transfer=transfer,
canonical_identifier=factories.make_canonical_identifier(),
)
assert hasattr(event, "balance_proof")
assert JSONSerializer.deserialize(JSONSerializer.serialize(event)) == event
def test_inplace_delete_message_queue(chain_state):
sender = factories.make_address()
canonical_identifier = factories.make_canonical_identifier()
message_id = factories.make_message_identifier()
delivered_state_change = ReceiveDelivered(sender=sender,
message_identifier=message_id)
processed_state_change = ReceiveProcessed(sender=sender,
message_identifier=message_id)
global_identifier = QueueIdentifier(
recipient=sender,
canonical_identifier=CANONICAL_IDENTIFIER_GLOBAL_QUEUE)
chain_state.queueids_to_queues[global_identifier] = None
assert global_identifier in chain_state.queueids_to_queues, "queue mapping insertion failed"
inplace_delete_message_queue(chain_state=chain_state,
state_change=delivered_state_change,
queueid=global_identifier)
assert global_identifier not in chain_state.queueids_to_queues, "did not clear queue"
chain_state.queueids_to_queues[global_identifier] = [
SendMessageEvent(
recipient=sender,
canonical_identifier=canonical_identifier,
message_identifier=message_id,
)
]
assert global_identifier in chain_state.queueids_to_queues, "queue mapping insertion failed"
handle_receive_delivered(chain_state=chain_state,
state_change=delivered_state_change)
assert global_identifier not in chain_state.queueids_to_queues, "did not clear queue"
queue_identifier = QueueIdentifier(
recipient=sender, canonical_identifier=canonical_identifier)
assert queue_identifier not in chain_state.queueids_to_queues, "queue not empty"
chain_state.queueids_to_queues[queue_identifier] = [
SendMessageEvent(
recipient=sender,
canonical_identifier=canonical_identifier,
message_identifier=message_id,
)
]
assert queue_identifier in chain_state.queueids_to_queues, "queue mapping not mutable"
handle_receive_processed(chain_state=chain_state,
state_change=processed_state_change)
assert queue_identifier not in chain_state.queueids_to_queues, "queue did not clear"