def detail_participants(_participant1, _participant2, _block_identifier,
_channel_identifier):
transferred_amount = TokenAmount(1)
locked_amount = LockedAmount(1)
locksroot = make_locksroot()
balance_hash = hash_balance_data(transferred_amount, locked_amount,
locksroot)
our_details = ParticipantDetails(
address=raiden.address,
deposit=TokenAmount(5),
withdrawn=WithdrawAmount(0),
is_closer=False,
balance_hash=balance_hash,
nonce=Nonce(1),
locksroot=locksroot,
locked_amount=locked_amount,
)
transferred_amount = TokenAmount(1)
locked_amount = LockedAmount(1)
# Let's mock here that partner locksroot is 0x0
balance_hash = hash_balance_data(transferred_amount, locked_amount,
locksroot)
partner_details = ParticipantDetails(
address=participant,
deposit=TokenAmount(5),
withdrawn=WithdrawAmount(0),
is_closer=True,
balance_hash=balance_hash,
nonce=Nonce(1),
locksroot=LOCKSROOT_OF_NO_LOCKS,
locked_amount=locked_amount,
)
return ParticipantsDetails(our_details, partner_details)
def test_receive_lockedtransfer_invalidnonce(raiden_network, number_of_nodes,
deposit, token_addresses,
reveal_timeout, network_wait):
app0, app1, app2 = raiden_network
token_address = token_addresses[0]
token_network_address = views.get_token_network_address_by_token_address(
views.state_from_app(app0), app0.raiden.default_registry.address,
token_address)
assert token_network_address
channel0 = get_channelstate(app0, app1, token_network_address)
amount = 10
payment_identifier = PaymentID(1)
secrethash = transfer(
initiator_app=app0,
target_app=app2,
token_address=token_address,
amount=PaymentAmount(10),
identifier=payment_identifier,
timeout=network_wait * number_of_nodes,
)
repeated_nonce = Nonce(1)
expiration = reveal_timeout * 2
mediated_transfer_message = LockedTransfer(
chain_id=UNIT_CHAIN_ID,
message_identifier=make_message_identifier(),
payment_identifier=payment_identifier,
nonce=repeated_nonce,
token_network_address=token_network_address,
token=token_address,
channel_identifier=channel0.identifier,
transferred_amount=TokenAmount(amount),
locked_amount=TokenAmount(amount),
recipient=app1.raiden.address,
locksroot=make_locksroot(),
lock=Lock(amount=PaymentWithFeeAmount(amount),
expiration=expiration,
secrethash=UNIT_SECRETHASH),
target=app2.raiden.address,
initiator=app0.raiden.address,
signature=EMPTY_SIGNATURE,
metadata=Metadata(routes=[
RouteMetadata(route=[app1.raiden.address, app2.raiden.address])
]),
)
sign_and_inject(mediated_transfer_message, app0.raiden.signer, app1)
with block_timeout_for_transfer_by_secrethash(app1.raiden, secrethash):
wait_assert(
assert_synced_channel_state,
token_network_address,
app0,
deposit - amount,
[],
app1,
deposit + amount,
[],
)
def test_write_read_log() -> None:
wal = new_wal(state_transition_noop)
block_number = BlockNumber(1337)
block_hash = make_block_hash()
block = Block(block_number=block_number,
gas_limit=BlockGasLimit(1),
block_hash=block_hash)
unlocked_amount = TokenAmount(10)
returned_amount = TokenAmount(5)
participant = make_address()
partner = make_address()
locksroot = make_locksroot()
contract_receive_unlock = ContractReceiveChannelBatchUnlock(
transaction_hash=make_transaction_hash(),
canonical_identifier=make_canonical_identifier(
token_network_address=make_address()),
receiver=participant,
sender=partner,
locksroot=locksroot,
unlocked_amount=unlocked_amount,
returned_tokens=returned_amount,
block_number=block_number,
block_hash=block_hash,
)
state_changes1 = wal.storage.get_statechanges_by_range(
RANGE_ALL_STATE_CHANGES)
count1 = len(state_changes1)
dispatch(wal, [block])
state_changes2 = wal.storage.get_statechanges_by_range(
RANGE_ALL_STATE_CHANGES)
count2 = len(state_changes2)
assert count1 + 1 == count2
dispatch(wal, [contract_receive_unlock])
state_changes3 = wal.storage.get_statechanges_by_range(
RANGE_ALL_STATE_CHANGES)
count3 = len(state_changes3)
assert count2 + 1 == count3
result1, result2 = state_changes3[-2:]
assert isinstance(result1, Block)
assert result1.block_number == block_number
assert isinstance(result2, ContractReceiveChannelBatchUnlock)
assert result2.receiver == participant
assert result2.sender == partner
assert result2.locksroot == locksroot
assert result2.unlocked_amount == unlocked_amount
assert result2.returned_tokens == returned_amount
# Make sure state snapshot can only go for corresponding state change ids
with pytest.raises(sqlite3.IntegrityError):
wal.storage.write_state_snapshot(State(), StateChangeID(make_ulid()),
1)
def test_received_lockedtransfer_closedchannel(raiden_network, reveal_timeout,
token_addresses, deposit):
app0, app1 = raiden_network
registry_address = app0.raiden.default_registry.address
token_address = token_addresses[0]
token_network_address = views.get_token_network_address_by_token_address(
views.state_from_app(app0), app0.raiden.default_registry.address,
token_address)
assert token_network_address
channel0 = get_channelstate(app0, app1, token_network_address)
RaidenAPI(app1.raiden).channel_close(registry_address, token_address,
app0.raiden.address)
app0.raiden.proxy_manager.wait_until_block(
target_block_number=app0.raiden.rpc_client.block_number() + 1)
# Now receive one mediated transfer for the closed channel
lock_amount = TokenAmount(10)
payment_identifier = PaymentID(1)
expiration = reveal_timeout * 2
mediated_transfer_message = LockedTransfer(
chain_id=UNIT_CHAIN_ID,
message_identifier=make_message_identifier(),
payment_identifier=payment_identifier,
nonce=Nonce(1),
token_network_address=token_network_address,
token=token_address,
channel_identifier=channel0.identifier,
transferred_amount=TokenAmount(0),
locked_amount=lock_amount,
recipient=app1.raiden.address,
locksroot=make_locksroot(),
lock=Lock(
amount=PaymentWithFeeAmount(lock_amount),
expiration=expiration,
secrethash=UNIT_SECRETHASH,
),
target=app1.raiden.address,
initiator=app0.raiden.address,
signature=EMPTY_SIGNATURE,
metadata=Metadata(routes=[RouteMetadata(route=[app1.raiden.address])]),
)
sign_and_inject(mediated_transfer_message, app0.raiden.signer, app1)
# The local state must not change since the channel is already closed
assert_synced_channel_state(token_network_address, app0, deposit, [], app1,
deposit, [])
def test_receive_lockedtransfer_invalidrecipient(raiden_network,
token_addresses,
reveal_timeout, deposit):
app0, app1 = raiden_network
token_address = token_addresses[0]
token_network_address = views.get_token_network_address_by_token_address(
views.state_from_app(app0), app0.raiden.default_registry.address,
token_address)
assert token_network_address
channel0 = get_channelstate(app0, app1, token_network_address)
payment_identifier = PaymentID(1)
invalid_recipient = make_address()
lock_amount = TokenAmount(10)
expiration = reveal_timeout * 2
mediated_transfer_message = LockedTransfer(
chain_id=UNIT_CHAIN_ID,
message_identifier=make_message_identifier(),
payment_identifier=payment_identifier,
nonce=Nonce(1),
token_network_address=token_network_address,
token=token_address,
channel_identifier=channel0.identifier,
transferred_amount=TokenAmount(0),
locked_amount=lock_amount,
recipient=invalid_recipient,
locksroot=make_locksroot(),
lock=Lock(
amount=PaymentWithFeeAmount(lock_amount),
expiration=expiration,
secrethash=UNIT_SECRETHASH,
),
target=app1.raiden.address,
initiator=app0.raiden.address,
signature=EMPTY_SIGNATURE,
metadata=Metadata(routes=[RouteMetadata(route=[app1.raiden.address])]),
)
sign_and_inject(mediated_transfer_message, app0.raiden.signer, app1)
assert_synced_channel_state(token_network_address, app0, deposit, [], app1,
deposit, [])
def test_receive_lockedtransfer_invalidsender(
raiden_network: List[RaidenService], token_addresses, deposit, reveal_timeout
):
app0, app1 = raiden_network
token_address = token_addresses[0]
other_key, other_address = make_privkey_address()
token_network_address = views.get_token_network_address_by_token_address(
views.state_from_raiden(app0), app0.default_registry.address, token_address
)
assert token_network_address
channel0 = get_channelstate(app0, app1, token_network_address)
lock_amount = LockedAmount(10)
expiration = reveal_timeout * 2
mediated_transfer_message = LockedTransfer(
chain_id=UNIT_CHAIN_ID,
message_identifier=make_message_identifier(),
payment_identifier=PaymentID(1),
nonce=Nonce(1),
token_network_address=token_network_address,
token=token_address,
channel_identifier=channel0.identifier,
transferred_amount=TokenAmount(0),
locked_amount=lock_amount,
recipient=app0.address,
locksroot=make_locksroot(),
lock=Lock(
amount=PaymentWithFeeAmount(lock_amount),
expiration=expiration,
secrethash=UNIT_SECRETHASH,
),
target=TargetAddress(app0.address),
initiator=InitiatorAddress(other_address),
signature=EMPTY_SIGNATURE,
metadata=Metadata(routes=[RouteMetadata(route=[app0.address])]),
)
sign_and_inject(mediated_transfer_message, LocalSigner(other_key), app0)
assert_synced_channel_state(token_network_address, app0, deposit, [], app1, deposit, [])
