def test_secret_revealed(raiden_chain, deposit, settle_timeout, token_addresses):
app0, app1, app2 = raiden_chain
registry_address = app0.raiden.default_registry.address
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,
)
amount = 10
identifier = 1
secret = pending_mediated_transfer(
raiden_chain,
token_network_identifier,
amount,
identifier,
)
secrethash = sha3(secret)
gevent.sleep(.1) # wait for the messages
channel_state2_1 = get_channelstate(app2, app1, token_network_identifier)
# the secret hasn't been revealed yet (through messages)
assert len(channel_state2_1.our_state.secrethashes_to_lockedlocks) == 1
proofs = list(channel.get_known_unlocks(channel_state2_1.our_state))
assert not proofs
channel.register_secret(channel_state2_1, secret, secrethash)
# Close the channel
netting_channel_proxy = app2.raiden.chain.netting_channel(channel_state2_1.identifier)
netting_channel_proxy.channel_close(
registry_address,
channel_state2_1.partner_state.balance_proof,
)
# Reveal the secret through the blockchain (this needs to emit the
# SecretRevealed event)
for unlock_proof in channel.get_known_unlocks(channel_state2_1.partner_state):
netting_channel_proxy.unlock(unlock_proof)
settle_expiration = app0.raiden.chain.block_number() + settle_timeout
wait_until_block(app0.raiden.chain, settle_expiration)
assert_synched_channel_state(
token_address,
app1, deposit - amount, [],
app2, deposit + amount, [],
)
assert_synched_channel_state(
token_address,
app0, deposit - amount, [],
app1, deposit + amount, [],
)
def test_withdraw_twice(tester_registry_address, reveal_timeout, tester_channels, tester_chain):
""" A lock can be withdrawn only once, the second try must fail. """
pkey0, pkey1, nettingchannel, channel0, channel1 = tester_channels[0]
pseudo_random_generator = random.Random()
lock_expiration = tester_chain.block.number + reveal_timeout + 5
secret = b'secretsecretsecretsecretsecretse'
new_block = Block(tester_chain.block.number)
channel.state_transition(
channel0,
new_block,
pseudo_random_generator,
new_block.block_number,
)
channel.state_transition(
channel1,
new_block,
pseudo_random_generator,
new_block.block_number,
)
lock = Lock(17, lock_expiration, sha3(secret))
mediated0 = make_mediated_transfer(
tester_registry_address,
channel1,
channel0,
privatekey_to_address(pkey1),
privatekey_to_address(pkey0),
lock,
pkey1,
secret,
)
mediated0_hash = sha3(mediated0.packed().data[:-65])
nettingchannel.close(
mediated0.nonce,
mediated0.transferred_amount,
mediated0.locksroot,
mediated0_hash,
mediated0.signature,
sender=pkey0,
)
unlock_proofs = channel.get_known_unlocks(channel0.partner_state)
proof = unlock_proofs[0]
nettingchannel.withdraw(
proof.lock_encoded,
b''.join(proof.merkle_proof),
proof.secret,
sender=pkey0,
)
with pytest.raises(TransactionFailed):
nettingchannel.withdraw(
proof.lock_encoded,
b''.join(proof.merkle_proof),
proof.secret,
sender=pkey0,
)
def test_withdraw_expired_lock(reveal_timeout, tester_channels, tester_chain):
pkey0, pkey1, nettingchannel, channel0, channel1 = tester_channels[0]
pseudo_random_generator = random.Random()
lock_timeout = reveal_timeout + 5
lock_expiration = tester_chain.block.number + lock_timeout
secret = b'expiredlockexpiredlockexpiredloc'
secrethash = sha3(secret)
new_block = Block(tester_chain.block.number)
channel.state_transition(
channel0,
new_block,
pseudo_random_generator,
new_block.block_number,
)
channel.state_transition(
channel1,
new_block,
pseudo_random_generator,
new_block.block_number,
)
lock1 = Lock(amount=31, expiration=lock_expiration, secrethash=secrethash)
mediated0 = make_mediated_transfer(
channel1,
channel0,
privatekey_to_address(pkey0),
privatekey_to_address(pkey1),
lock1,
pkey1,
secret,
)
mediated0_hash = sha3(mediated0.packed().data[:-65])
nettingchannel.close(
mediated0.nonce,
mediated0.transferred_amount,
mediated0.locksroot,
mediated0_hash,
mediated0.signature,
sender=pkey0,
)
# expire the lock
tester_chain.mine(number_of_blocks=lock_timeout + 1)
unlock_proofs = channel.get_known_unlocks(channel0.partner_state)
proof = unlock_proofs[0]
with pytest.raises(TransactionFailed):
nettingchannel.withdraw(
proof.lock_encoded,
b''.join(proof.merkle_proof),
proof.secret,
sender=pkey0,
)
def test_new_end_state():
"""Test the defaults for an end state object."""
balance1 = 101
node_address = factories.make_address()
end_state = NettingChannelEndState(node_address, balance1)
lock_secret = sha3(b'test_end_state')
lock_secrethash = sha3(lock_secret)
assert channel.is_lock_pending(end_state, lock_secrethash) is False
assert channel.is_lock_locked(end_state, lock_secrethash) is False
assert channel.get_next_nonce(end_state) == 1
assert channel.get_amount_locked(end_state) == 0
assert not channel.get_known_unlocks(end_state)
assert merkleroot(end_state.merkletree) == EMPTY_MERKLE_ROOT
assert not end_state.secrethashes_to_lockedlocks
assert not end_state.secrethashes_to_unlockedlocks
def test_withdraw_lock_with_a_large_expiration(
tester_registry_address,
deposit,
tester_channels,
tester_chain,
tester_token,
settle_timeout,
):
""" Withdraw must accept a lock that expires after the settlement period. """
pkey0, pkey1, nettingchannel, channel0, channel1 = tester_channels[0]
address0 = privatekey_to_address(pkey0)
address1 = privatekey_to_address(pkey1)
pseudo_random_generator = random.Random()
initial_balance0 = tester_token.balanceOf(address0, sender=pkey0)
initial_balance1 = tester_token.balanceOf(address1, sender=pkey0)
# use a really large expiration
lock_expiration = tester_chain.block.number + settle_timeout * 5
# work around for the python expiration validation
bad_block_number = lock_expiration - 10
channel.state_transition(
channel0,
Block(bad_block_number),
pseudo_random_generator,
bad_block_number,
)
lock_amount = 29
secret = sha3(b'test_withdraw_lock_with_a_large_expiration')
lock_secrethash = sha3(secret)
lock = Lock(
amount=lock_amount,
expiration=lock_expiration,
secrethash=lock_secrethash,
)
mediated0 = make_mediated_transfer(
tester_registry_address,
channel0,
channel1,
address0,
address1,
lock,
pkey0,
secret,
)
nettingchannel.close(sender=pkey0)
mediated0_hash = sha3(mediated0.packed().data[:-65])
nettingchannel.updateTransfer(
mediated0.nonce,
mediated0.transferred_amount,
mediated0.locksroot,
mediated0_hash,
mediated0.signature,
sender=pkey1,
)
unlock_proofs = channel.get_known_unlocks(channel1.partner_state)
proof = unlock_proofs[0]
nettingchannel.withdraw(
proof.lock_encoded,
b''.join(proof.merkle_proof),
proof.secret,
sender=pkey1,
)
tester_chain.mine(number_of_blocks=settle_timeout + 1)
nettingchannel.settle(sender=pkey0)
balance0 = initial_balance0 + deposit - lock_amount
balance1 = initial_balance1 + deposit + lock_amount
assert tester_token.balanceOf(address0, sender=pkey0) == balance0
assert tester_token.balanceOf(address1, sender=pkey0) == balance1
assert tester_token.balanceOf(nettingchannel.address, sender=pkey0) == 0
