def make_signed_transfer_from_counter(counter):
lock = Lock(
amount=next(counter),
expiration=next(counter),
secrethash=factories.make_secret_hash(next(counter)),
)
signed_transfer = factories.create(
factories.LockedTransferSignedStateProperties(
amount=next(counter),
initiator=factories.make_initiator_address(),
target=factories.make_target_address(),
expiration=next(counter),
secret=factories.make_secret(next(counter)),
payment_identifier=next(counter),
token=factories.make_token_address(),
nonce=next(counter),
transferred_amount=next(counter),
locked_amount=next(counter),
locksroot=sha3(lock.as_bytes),
canonical_identifier=factories.make_canonical_identifier(
token_network_address=factories.make_address(),
channel_identifier=next(counter)),
recipient=factories.make_address(),
sender=factories.HOP1,
pkey=factories.HOP1_KEY,
))
return signed_transfer
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 __post_init__(self) -> None:
typecheck(self.amount, T_PaymentWithFeeAmount)
typecheck(self.expiration, T_BlockNumber)
typecheck(self.secrethash, T_Secret)
from raiden.messages.transfers import Lock # put here to avoid cyclic depenendcies
lock = Lock(amount=self.amount, expiration=self.expiration, secrethash=self.secrethash)
self.encoded = EncodedData(lock.as_bytes)
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 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
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, [])
def test_regression_multiple_revealsecret(
raiden_network: List[App],
token_addresses: List[TokenAddress]) -> None:
""" Multiple RevealSecret messages arriving at the same time must be
handled properly.
Unlock handling followed these steps:
The Unlock message arrives
The secret is registered
The channel is updated and the correspoding lock is removed
* A balance proof for the new channel state is created and sent to the
payer
The channel is unregistered for the given secrethash
The step marked with an asterisk above introduced a context-switch. This
allowed a second Reveal Unlock message to be handled before the channel was
unregistered. And because the channel was already updated an exception was raised
for an unknown secret.
"""
app0, app1 = raiden_network
token = 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)
assert token_network_address
channelstate_0_1 = get_channelstate(app0, app1, token_network_address)
payment_identifier = PaymentID(1)
secret, secrethash = make_secret_with_hash()
expiration = BlockExpiration(app0.raiden.get_block_number() + 100)
lock_amount = PaymentWithFeeAmount(10)
lock = Lock(amount=lock_amount,
expiration=expiration,
secrethash=secrethash)
nonce = Nonce(1)
transferred_amount = TokenAmount(0)
mediated_transfer = LockedTransfer(
chain_id=UNIT_CHAIN_ID,
message_identifier=make_message_identifier(),
payment_identifier=payment_identifier,
nonce=nonce,
token_network_address=token_network_address,
token=token,
channel_identifier=channelstate_0_1.identifier,
transferred_amount=transferred_amount,
locked_amount=LockedAmount(lock_amount),
recipient=app1.raiden.address,
locksroot=Locksroot(lock.lockhash),
lock=lock,
target=TargetAddress(app1.raiden.address),
initiator=InitiatorAddress(app0.raiden.address),
signature=EMPTY_SIGNATURE,
metadata=Metadata(routes=[
RouteMetadata(route=[app0.raiden.address, app1.raiden.address])
]),
)
app0.raiden.sign(mediated_transfer)
app1.raiden.on_messages([mediated_transfer])
reveal_secret = RevealSecret(message_identifier=make_message_identifier(),
secret=secret,
signature=EMPTY_SIGNATURE)
app0.raiden.sign(reveal_secret)
token_network_address = channelstate_0_1.token_network_address
unlock = Unlock(
chain_id=UNIT_CHAIN_ID,
message_identifier=make_message_identifier(),
payment_identifier=payment_identifier,
nonce=Nonce(mediated_transfer.nonce + 1),
token_network_address=token_network_address,
channel_identifier=channelstate_0_1.identifier,
transferred_amount=TokenAmount(lock_amount),
locked_amount=LockedAmount(0),
locksroot=LOCKSROOT_OF_NO_LOCKS,
secret=secret,
signature=EMPTY_SIGNATURE,
)
app0.raiden.sign(unlock)
messages = [unlock, reveal_secret]
receive_method = app1.raiden.on_messages
wait = set(
gevent.spawn_later(0.1, receive_method, [data]) for data in messages)
gevent.joinall(wait, raise_error=True)
def make_receive_transfer_mediated(
channel_state: NettingChannelState,
privkey: bytes,
nonce: Nonce,
transferred_amount: TokenAmount,
lock: HashTimeLockState,
pending_locks: PendingLocksState = None,
locked_amount: Optional[PaymentWithFeeAmount] = None,
chain_id: Optional[ChainID] = None,
) -> LockedTransferSignedState:
typecheck(lock, HashTimeLockState)
signer = LocalSigner(privkey)
address = signer.address
if address not in (channel_state.our_state.address,
channel_state.partner_state.address):
raise ValueError("Private key does not match any of the participants.")
if pending_locks is None:
locks = make_empty_pending_locks_state()
locks.locks.append(lock.encoded)
else:
assert bytes(lock.encoded) in pending_locks.locks
locks = pending_locks
if locked_amount is None:
locked_amount = lock.amount
assert locked_amount >= lock.amount
locksroot = compute_locksroot(locks)
payment_identifier = PaymentID(nonce)
transfer_target = make_target_address()
transfer_initiator = make_initiator_address()
chain_id = chain_id or channel_state.chain_id
transfer_metadata = Metadata(routes=[
RouteMetadata(
route=[channel_state.our_state.address,
Address(transfer_target)])
])
mediated_transfer_msg = LockedTransfer(
chain_id=chain_id,
message_identifier=make_message_identifier(),
payment_identifier=payment_identifier,
nonce=nonce,
token_network_address=channel_state.token_network_address,
token=channel_state.token_address,
channel_identifier=channel_state.identifier,
transferred_amount=transferred_amount,
locked_amount=TokenAmount(locked_amount),
recipient=channel_state.partner_state.address,
locksroot=locksroot,
lock=Lock(amount=lock.amount,
expiration=lock.expiration,
secrethash=lock.secrethash),
target=transfer_target,
initiator=transfer_initiator,
signature=EMPTY_SIGNATURE,
fee=0,
metadata=transfer_metadata,
)
mediated_transfer_msg.sign(signer)
receive_lockedtransfer = LockedTransferSignedState(
payment_identifier=payment_identifier,
token=channel_state.token_address,
lock=lock,
initiator=transfer_initiator,
target=transfer_target,
message_identifier=make_message_identifier(),
balance_proof=balanceproof_from_envelope(mediated_transfer_msg),
routes=[
route_metadata.route for route_metadata in transfer_metadata.routes
],
)
return receive_lockedtransfer