def handle_channel_closed(raiden, event, current_block_number):
registry_address = event.event_data['registry_address']
channel_identifier = event.originating_contract
data = event.event_data
channel_state = views.search_for_channel(
views.state_from_raiden(raiden),
registry_address,
channel_identifier,
)
if channel_state:
token_network_identifier = views.get_token_network_identifier_by_token_address(
views.state_from_raiden(raiden),
registry_address,
channel_state.token_address,
)
channel_closed = ContractReceiveChannelClosed(
token_network_identifier,
channel_identifier,
data['closing_address'],
data['block_number'],
)
raiden.handle_state_change(channel_closed, current_block_number)
def handle_channel_closed(raiden: RaidenService, event: Event):
token_network_identifier = event.originating_contract
data = event.event_data
block_number = data['block_number']
args = data['args']
channel_identifier = args['channel_identifier']
transaction_hash = data['transaction_hash']
channel_state = views.get_channelstate_by_token_network_identifier(
views.state_from_raiden(raiden),
token_network_identifier,
channel_identifier,
)
if channel_state:
# The from address is included in the ChannelClosed event as the
# closing_participant field
channel_closed = ContractReceiveChannelClosed(
transaction_hash=transaction_hash,
transaction_from=args['closing_participant'],
token_network_identifier=token_network_identifier,
channel_identifier=channel_identifier,
block_number=block_number,
)
raiden.handle_state_change(channel_closed)
else:
# This is a channel close event of a channel we're not a participant of
route_closed = ContractReceiveRouteClosed(
transaction_hash=transaction_hash,
token_network_identifier=token_network_identifier,
channel_identifier=channel_identifier,
block_number=block_number,
)
raiden.handle_state_change(route_closed)
def test_channel_withdraw_must_not_change_merkletree():
our_model1, _ = create_model(70)
partner_model1, privkey2 = create_model(100)
channel_state = create_channel_from_models(our_model1, partner_model1)
payment_network_identifier = factories.make_address()
lock_amount = 10
lock_expiration = 100
lock_secret = sha3(b'test_channelstate_lockedtransfer_overspent')
lock_secrethash = sha3(lock_secret)
lock = HashTimeLockState(
lock_amount,
lock_expiration,
lock_secrethash,
)
nonce = 1
transferred_amount = 0
receive_lockedtransfer = make_receive_transfer_mediated(
channel_state,
privkey2,
nonce,
transferred_amount,
lock,
)
is_valid, _, msg = channel.handle_receive_lockedtransfer(
channel_state,
receive_lockedtransfer,
)
assert is_valid, msg
assert merkleroot(channel_state.partner_state.merkletree) == lock.lockhash
assert channel.is_lock_pending(channel_state.partner_state,
lock.secrethash)
closed_block_number = lock_expiration - channel_state.reveal_timeout - 1
state_change = ContractReceiveChannelClosed(
payment_network_identifier,
channel_state.token_address,
channel_state.identifier,
partner_model1.participant_address,
closed_block_number,
)
iteration = channel.handle_channel_closed(channel_state, state_change)
new_channel = iteration.new_state
withdraw = ContractReceiveChannelWithdraw(
payment_network_identifier,
channel_state.token_address,
channel_state.identifier,
lock_secret,
channel_state.our_state.address,
)
iteration = channel.handle_channel_withdraw(new_channel, withdraw)
new_channel = iteration.new_state
assert merkleroot(new_channel.partner_state.merkletree) == lock.lockhash
assert not channel.is_lock_pending(new_channel.partner_state,
lock.secrethash)
def handle_channel_closed(raiden, event, current_block_number):
token_network_identifier = event.originating_contract
data = event.event_data
channel_identifier = data['channel_identifier']
transaction_hash = data['transactionHash']
assert transaction_hash, 'A mined transaction must have the hash field'
channel_state = views.get_channelstate_by_token_network_identifier(
views.state_from_raiden(raiden),
token_network_identifier,
channel_identifier,
)
if channel_state:
# The from address is included in the ChannelClosed event as the
# closing_participant field
channel_closed = ContractReceiveChannelClosed(
transaction_hash=transaction_hash,
transaction_from=data['closing_participant'],
token_network_identifier=token_network_identifier,
channel_identifier=channel_identifier,
closed_block_number=data['block_number'],
)
raiden.handle_state_change(channel_closed, current_block_number)
else:
# This is a channel close event of a channel we're not a participant of
channel_closed = ContractReceiveRouteClosed(
transaction_hash=transaction_hash,
token_network_identifier=token_network_identifier,
channel_identifier=channel_identifier,
)
raiden.handle_state_change(channel_closed, current_block_number)
def handle_channel_closed(raiden: "RaidenService", event: Event):
token_network_identifier = event.originating_contract
data = event.event_data
block_number = data["block_number"]
args = data["args"]
channel_identifier = args["channel_identifier"]
transaction_hash = data["transaction_hash"]
block_hash = data["block_hash"]
chain_state = views.state_from_raiden(raiden)
channel_state = views.get_channelstate_by_canonical_identifier_and_address(
chain_state=chain_state,
canonical_identifier=CanonicalIdentifier(
chain_identifier=chain_state.chain_id,
token_network_address=token_network_identifier,
channel_identifier=channel_identifier,
),
address=args['closing_participant'],
)
channel_closed: StateChange
if channel_state:
# The from address is included in the ChannelClosed event as the
# closing_participant field
if raiden.address == channel_state.our_state.address:
channel_closed = ContractReceiveChannelClosed(
transaction_hash=transaction_hash,
transaction_from=args["closing_participant"],
canonical_identifier=channel_state.canonical_identifier,
block_number=block_number,
block_hash=block_hash,
)
raiden.handle_and_track_state_change(channel_closed)
else:
# Must be a light client
latest_non_closing_balance_proof = LightClientMessageHandler.get_latest_light_client_non_closing_balance_proof(
channel_state.identifier, raiden.wal.storage)
channel_closed = ContractReceiveChannelClosedLight(
transaction_hash=transaction_hash,
transaction_from=args["closing_participant"],
canonical_identifier=channel_state.canonical_identifier,
block_number=block_number,
block_hash=block_hash,
light_client_address=channel_state.our_state.address,
latest_update_non_closing_balance_proof_data=
latest_non_closing_balance_proof)
raiden.handle_and_track_state_change(channel_closed)
else:
# This is a channel close event of a channel we're not a participant of
route_closed = ContractReceiveRouteClosed(
transaction_hash=transaction_hash,
canonical_identifier=CanonicalIdentifier(
chain_identifier=chain_state.chain_id,
token_network_address=token_network_identifier,
channel_identifier=channel_identifier,
),
block_number=block_number,
block_hash=block_hash,
)
raiden.handle_and_track_state_change(route_closed)
def test_channelstate_unlock():
"""The node must call unlock after the channel is settled"""
our_model1, _ = create_model(70)
partner_model1, privkey2 = create_model(100)
channel_state = create_channel_from_models(our_model1, partner_model1)
lock_amount = 10
lock_expiration = 100
lock_secret = sha3(b'test_channelstate_lockedtransfer_overspent')
lock_secrethash = sha3(lock_secret)
lock = HashTimeLockState(
lock_amount,
lock_expiration,
lock_secrethash,
)
nonce = 1
transferred_amount = 0
receive_lockedtransfer = make_receive_transfer_mediated(
channel_state,
privkey2,
nonce,
transferred_amount,
lock,
)
is_valid, _, msg = channel.handle_receive_lockedtransfer(
channel_state,
receive_lockedtransfer,
)
assert is_valid, msg
channel.register_secret(channel_state, lock_secret, lock_secrethash)
closed_block_number = lock_expiration - channel_state.reveal_timeout - 1
close_state_change = ContractReceiveChannelClosed(
channel_state.token_network_identifier,
channel_state.identifier,
partner_model1.participant_address,
closed_block_number,
)
iteration = channel.handle_channel_closed(channel_state, close_state_change)
assert not must_contain_entry(iteration.events, ContractSendChannelBatchUnlock, {})
settle_block_number = lock_expiration + channel_state.reveal_timeout + 1
settle_state_change = ContractReceiveChannelSettled(
channel_state.token_network_identifier,
channel_state.identifier,
settle_block_number,
)
iteration = channel.handle_channel_settled(
channel_state,
settle_state_change,
settle_block_number,
)
assert must_contain_entry(iteration.events, ContractSendChannelBatchUnlock, {})
def test_channel_settle_must_properly_cleanup():
open_block_number = 10
pseudo_random_generator = random.Random()
token_network_id = factories.make_address()
token_id = factories.make_address()
token_network_state = TokenNetworkState(token_network_id, token_id)
amount = 30
our_balance = amount + 50
channel_state = factories.make_channel(our_balance=our_balance)
channel_new_state_change = ContractReceiveChannelNew(
token_network_id, channel_state)
channel_new_iteration = token_network.state_transition(
token_network_state,
channel_new_state_change,
pseudo_random_generator,
open_block_number,
)
closed_block_number = open_block_number + 10
channel_close_state_change = ContractReceiveChannelClosed(
token_network_id,
channel_state.identifier,
channel_state.partner_state.address,
closed_block_number,
)
channel_closed_iteration = token_network.state_transition(
channel_new_iteration.new_state,
channel_close_state_change,
pseudo_random_generator,
closed_block_number,
)
settle_block_number = closed_block_number + channel_state.settle_timeout + 1
channel_settled_state_change = ContractReceiveChannelSettled(
token_network_id,
channel_state.identifier,
settle_block_number,
)
channel_settled_iteration = token_network.state_transition(
channel_closed_iteration.new_state,
channel_settled_state_change,
pseudo_random_generator,
closed_block_number,
)
token_network_state_after_settle = channel_settled_iteration.new_state
ids_to_channels = token_network_state_after_settle.channelidentifiers_to_channels
assert channel_state.identifier not in ids_to_channels
def test_initiator_handle_contract_receive_after_channel_closed():
""" Initiator must accept on-chain secret reveal if the channel is closed.
However, the off-chain unlock must not be done!
This will happen because secrets are registered after a channel is closed,
during the settlement window.
"""
block_number = 10
setup = setup_initiator_tests(amount=UNIT_TRANSFER_AMOUNT * 2,
block_number=block_number)
transfer = setup.current_state.initiator.transfer
assert transfer.lock.secrethash in setup.channel.our_state.secrethashes_to_lockedlocks
channel_closed = ContractReceiveChannelClosed(
transaction_hash=factories.make_transaction_hash(),
transaction_from=factories.make_address(),
token_network_identifier=setup.channel.token_network_identifier,
channel_identifier=setup.channel.identifier,
block_number=block_number,
)
channel_close_transition = channel.state_transition(
channel_state=setup.channel,
state_change=channel_closed,
pseudo_random_generator=setup.prng,
block_number=block_number,
)
channel_state = channel_close_transition.new_state
state_change = ContractReceiveSecretReveal(
transaction_hash=factories.make_transaction_hash(),
secret_registry_address=factories.make_address(),
secrethash=transfer.lock.secrethash,
secret=UNIT_SECRET,
block_number=transfer.lock.expiration,
)
channel_map = {
channel_state.identifier: channel_state,
}
iteration = initiator_manager.handle_onchain_secretreveal(
payment_state=setup.current_state,
state_change=state_change,
channelidentifiers_to_channels=channel_map,
pseudo_random_generator=setup.prng,
)
secrethash = setup.current_state.initiator.transfer_description.secrethash
assert secrethash in channel_state.our_state.secrethashes_to_onchain_unlockedlocks
msg = 'The channel is closed already, the balance proof must not be sent off-chain'
assert not events.must_contain_entry(iteration.events, SendBalanceProof,
{}), msg
def test_channelstate_withdraw_without_locks():
"""Event close must be properly handled if there are no locks to unlock"""
our_model1, _ = create_model(70)
partner_model1, _ = create_model(100)
channel_state = create_channel_from_models(our_model1, partner_model1)
closed_block_number = 77
state_change = ContractReceiveChannelClosed(
channel_state.identifier,
partner_model1.participant_address,
closed_block_number,
)
iteration = channel.handle_channel_closed(channel_state, state_change)
assert not iteration.events
def contractreceivechannelclosed_from_event(
canonical_identifier: CanonicalIdentifier,
event: DecodedEvent) -> ContractReceiveChannelClosed:
data = event.event_data
args = data["args"]
# The from address is included in the ChannelClosed event as the
# closing_participant field
return ContractReceiveChannelClosed(
transaction_from=args["closing_participant"],
canonical_identifier=canonical_identifier,
transaction_hash=event.transaction_hash,
block_number=event.block_number,
block_hash=event.block_hash,
)
def test_channelstate_withdraw():
"""Event close must be properly handled if there are no locks to unlock"""
our_model1, _ = create_model(70)
partner_model1, privkey2 = create_model(100)
channel_state = create_channel_from_models(our_model1, partner_model1)
payment_network_identifier = factories.make_address()
lock_amount = 10
lock_expiration = 100
lock_secret = sha3(b'test_channelstate_lockedtransfer_overspent')
lock_secrethash = sha3(lock_secret)
lock = HashTimeLockState(
lock_amount,
lock_expiration,
lock_secrethash,
)
nonce = 1
transferred_amount = 0
receive_lockedtransfer = make_receive_transfer_mediated(
channel_state,
privkey2,
nonce,
transferred_amount,
lock,
)
is_valid, _, msg = channel.handle_receive_lockedtransfer(
channel_state,
receive_lockedtransfer,
)
assert is_valid, msg
channel.register_secret(channel_state, lock_secret, lock_secrethash)
# If the channel is closed, withdraw must be done even if the lock is not
# at risk of expiring
closed_block_number = lock_expiration - channel_state.reveal_timeout - 1
state_change = ContractReceiveChannelClosed(
payment_network_identifier,
channel_state.token_address,
channel_state.identifier,
partner_model1.participant_address,
closed_block_number,
)
iteration = channel.handle_channel_closed(channel_state, state_change)
assert must_contain_entry(iteration.events, ContractSendChannelWithdraw,
{})
def handle_channel_closed(raiden: "RaidenService", event: Event):
token_network_identifier = event.originating_contract
data = event.event_data
block_number = data["block_number"]
args = data["args"]
channel_identifier = args["channel_identifier"]
transaction_hash = data["transaction_hash"]
block_hash = data["block_hash"]
chain_state = views.state_from_raiden(raiden)
channel_state = views.get_channelstate_by_canonical_identifier(
chain_state=chain_state,
canonical_identifier=CanonicalIdentifier(
chain_identifier=chain_state.chain_id,
token_network_address=token_network_identifier,
channel_identifier=channel_identifier,
),
)
channel_closed: StateChange
if channel_state:
# The from address is included in the ChannelClosed event as the
# closing_participant field
channel_closed = ContractReceiveChannelClosed(
transaction_hash=transaction_hash,
transaction_from=args["closing_participant"],
canonical_identifier=channel_state.canonical_identifier,
block_number=block_number,
block_hash=block_hash,
)
raiden.handle_and_track_state_change(channel_closed)
else:
# This is a channel close event of a channel we're not a participant of
route_closed = ContractReceiveRouteClosed(
transaction_hash=transaction_hash,
canonical_identifier=CanonicalIdentifier(
chain_identifier=chain_state.chain_id,
token_network_address=token_network_identifier,
channel_identifier=channel_identifier,
),
block_number=block_number,
block_hash=block_hash,
)
raiden.handle_and_track_state_change(route_closed)
def handle_channel_closed(raiden, event, current_block_number):
token_network_identifier = event.originating_contract
data = event.event_data
channel_identifier = data['channel_identifier']
channel_state = views.get_channelstate_by_token_network_identifier(
views.state_from_raiden(raiden),
token_network_identifier,
channel_identifier,
)
if channel_state:
channel_closed = ContractReceiveChannelClosed(
token_network_identifier,
channel_identifier,
data['closing_participant'],
data['block_number'],
)
raiden.handle_state_change(channel_closed, current_block_number)
def handle_channel_closed(raiden, event):
payment_network_identifier = raiden.default_registry.address
channel_identifier = event.originating_contract
data = event.event_data
channel_state = views.search_for_channel(
views.state_from_raiden(raiden),
payment_network_identifier,
channel_identifier,
)
if channel_state:
channel_closed = ContractReceiveChannelClosed(
payment_network_identifier,
channel_state.token_address,
channel_identifier,
data['closing_address'],
data['block_number'],
)
raiden.handle_state_change(channel_closed)
def test_initiator_lock_expired_must_not_be_sent_if_channel_is_closed():
""" If the channel is closed there is no rason to send balance proofs
off-chain, so a remove expired lock must not be sent when the channel is
closed.
"""
block_number = 10
setup = setup_initiator_tests(amount=UNIT_TRANSFER_AMOUNT * 2,
block_number=block_number)
channel_closed = ContractReceiveChannelClosed(
transaction_hash=factories.make_transaction_hash(),
transaction_from=factories.make_address(),
token_network_identifier=setup.channel.token_network_identifier,
channel_identifier=setup.channel.identifier,
block_number=block_number,
)
channel_close_transition = channel.state_transition(
channel_state=setup.channel,
state_change=channel_closed,
pseudo_random_generator=setup.prng,
block_number=block_number,
)
channel_state = channel_close_transition.new_state
expiration_block_number = setup.lock.expiration + DEFAULT_NUMBER_OF_BLOCK_CONFIRMATIONS * 2
block = Block(
block_number=expiration_block_number,
gas_limit=1,
block_hash=factories.make_transaction_hash(),
)
channel_map = {channel_state.identifier: channel_state}
iteration = initiator_manager.state_transition(
setup.current_state,
block,
channel_map,
setup.prng,
expiration_block_number,
)
assert events.must_contain_entry(iteration.events, SendLockExpired,
{}) is None
def test_routing_updates(
token_network_state,
our_address,
):
open_block_number = 10
pseudo_random_generator = random.Random()
pkey1, address1 = factories.make_privkey_address()
pkey2, address2 = factories.make_privkey_address()
pkey3, address3 = factories.make_privkey_address()
amount = 30
our_balance = amount + 50
channel_state = factories.make_channel(
our_balance=our_balance,
our_address=our_address,
partner_balance=our_balance,
partner_address=address1,
)
payment_network_identifier = factories.make_payment_network_identifier()
# create a new channel as participant, check graph update
channel_new_state_change = ContractReceiveChannelNew(
transaction_hash=factories.make_transaction_hash(),
token_network_identifier=token_network_state.address,
channel_state=channel_state,
)
channel_new_iteration1 = token_network.state_transition(
payment_network_identifier=payment_network_identifier,
token_network_state=token_network_state,
state_change=channel_new_state_change,
pseudo_random_generator=pseudo_random_generator,
block_number=open_block_number,
)
graph_state = channel_new_iteration1.new_state.network_graph
assert channel_state.identifier in graph_state.channel_identifier_to_participants
assert len(graph_state.channel_identifier_to_participants) == 1
assert graph_state.network[our_address][address1] is not None
assert len(graph_state.network.edges()) == 1
# create a new channel without being participant, check graph update
new_channel_identifier = factories.make_channel_identifier()
channel_new_state_change = ContractReceiveRouteNew(
transaction_hash=factories.make_transaction_hash(),
token_network_identifier=token_network_state.address,
channel_identifier=new_channel_identifier,
participant1=address2,
participant2=address3,
)
channel_new_iteration2 = token_network.state_transition(
payment_network_identifier=payment_network_identifier,
token_network_state=channel_new_iteration1.new_state,
state_change=channel_new_state_change,
pseudo_random_generator=pseudo_random_generator,
block_number=open_block_number + 10,
)
graph_state = channel_new_iteration2.new_state.network_graph
assert channel_state.identifier in graph_state.channel_identifier_to_participants
assert new_channel_identifier in graph_state.channel_identifier_to_participants
assert len(graph_state.channel_identifier_to_participants) == 2
assert graph_state.network[our_address][address1] is not None
assert graph_state.network[address2][address3] is not None
assert len(graph_state.network.edges()) == 2
# close the channel the node is a participant of, check edge is removed from graph
closed_block_number = open_block_number + 20
channel_close_state_change1 = ContractReceiveChannelClosed(
transaction_hash=factories.make_transaction_hash(),
transaction_from=channel_state.partner_state.address,
token_network_identifier=token_network_state.address,
channel_identifier=channel_state.identifier,
closed_block_number=closed_block_number,
)
channel_closed_iteration1 = token_network.state_transition(
payment_network_identifier=payment_network_identifier,
token_network_state=channel_new_iteration2.new_state,
state_change=channel_close_state_change1,
pseudo_random_generator=pseudo_random_generator,
block_number=closed_block_number,
)
graph_state = channel_closed_iteration1.new_state.network_graph
assert channel_state.identifier not in graph_state.channel_identifier_to_participants
assert new_channel_identifier in graph_state.channel_identifier_to_participants
assert len(graph_state.channel_identifier_to_participants) == 1
assert graph_state.network[address2][address3] is not None
assert len(graph_state.network.edges()) == 1
# close the channel the node is not a participant of, check edge is removed from graph
channel_close_state_change2 = ContractReceiveRouteClosed(
transaction_hash=factories.make_transaction_hash(),
token_network_identifier=token_network_state.address,
channel_identifier=new_channel_identifier,
)
channel_closed_iteration2 = token_network.state_transition(
payment_network_identifier=payment_network_identifier,
token_network_state=channel_closed_iteration1.new_state,
state_change=channel_close_state_change2,
pseudo_random_generator=pseudo_random_generator,
block_number=closed_block_number + 10,
)
graph_state = channel_closed_iteration2.new_state.network_graph
assert channel_state.identifier not in graph_state.channel_identifier_to_participants
assert new_channel_identifier not in graph_state.channel_identifier_to_participants
assert len(graph_state.channel_identifier_to_participants) == 0
assert len(graph_state.network.edges()) == 0
def test_multiple_channel_states(
chain_state,
token_network_state,
our_address,
):
open_block_number = 10
pseudo_random_generator = random.Random()
pkey, address = factories.make_privkey_address()
amount = 30
our_balance = amount + 50
channel_state = factories.make_channel(
our_balance=our_balance,
our_address=our_address,
partner_balance=our_balance,
partner_address=address,
)
payment_network_identifier = factories.make_payment_network_identifier()
channel_new_state_change = ContractReceiveChannelNew(
factories.make_transaction_hash(),
token_network_state.address,
channel_state,
)
channel_new_iteration = token_network.state_transition(
payment_network_identifier,
token_network_state,
channel_new_state_change,
pseudo_random_generator,
open_block_number,
)
lock_amount = 30
lock_expiration = 20
lock_secret = sha3(b'test_end_state')
lock_secrethash = sha3(lock_secret)
lock = HashTimeLockState(
lock_amount,
lock_expiration,
lock_secrethash,
)
mediated_transfer = make_receive_transfer_mediated(
channel_state=channel_state,
privkey=pkey,
nonce=1,
transferred_amount=0,
lock=lock,
token_network_address=token_network_state.address,
)
from_route = factories.route_from_channel(channel_state)
init_target = ActionInitTarget(
from_route,
mediated_transfer,
)
node.state_transition(chain_state, init_target)
closed_block_number = open_block_number + 10
channel_close_state_change = ContractReceiveChannelClosed(
factories.make_transaction_hash(),
channel_state.partner_state.address,
token_network_state.address,
channel_state.identifier,
closed_block_number,
)
channel_closed_iteration = token_network.state_transition(
payment_network_identifier,
channel_new_iteration.new_state,
channel_close_state_change,
pseudo_random_generator,
closed_block_number,
)
settle_block_number = closed_block_number + channel_state.settle_timeout + 1
channel_settled_state_change = ContractReceiveChannelSettled(
factories.make_transaction_hash(),
token_network_state.address,
channel_state.identifier,
settle_block_number,
)
channel_settled_iteration = token_network.state_transition(
payment_network_identifier,
channel_closed_iteration.new_state,
channel_settled_state_change,
pseudo_random_generator,
closed_block_number,
)
token_network_state_after_settle = channel_settled_iteration.new_state
ids_to_channels = token_network_state_after_settle.channelidentifiers_to_channels
assert len(ids_to_channels) == 1
assert channel_state.identifier in ids_to_channels
# Create new channel while the previous one is pending unlock
new_channel_state = factories.make_channel(
our_balance=our_balance,
partner_balance=our_balance,
partner_address=address,
)
channel_new_state_change = ContractReceiveChannelNew(
factories.make_transaction_hash(),
token_network_state.address,
new_channel_state,
)
channel_new_iteration = token_network.state_transition(
payment_network_identifier,
token_network_state,
channel_new_state_change,
pseudo_random_generator,
open_block_number,
)
token_network_state_after_new_open = channel_new_iteration.new_state
ids_to_channels = token_network_state_after_new_open.channelidentifiers_to_channels
assert len(ids_to_channels) == 2
assert channel_state.identifier in ids_to_channels
def test_channel_data_removed_after_unlock(
chain_state,
token_network_state,
our_address,
):
open_block_number = 10
pseudo_random_generator = random.Random()
pkey, address = factories.make_privkey_address()
amount = 30
our_balance = amount + 50
channel_state = factories.make_channel(
our_balance=our_balance,
our_address=our_address,
partner_balance=our_balance,
partner_address=address,
token_network_identifier=token_network_state.address,
)
payment_network_identifier = factories.make_payment_network_identifier()
channel_new_state_change = ContractReceiveChannelNew(
factories.make_transaction_hash(),
token_network_state.address,
channel_state,
open_block_number,
)
channel_new_iteration = token_network.state_transition(
payment_network_identifier,
token_network_state,
channel_new_state_change,
pseudo_random_generator,
open_block_number,
)
lock_amount = 30
lock_expiration = 20
lock_secret = sha3(b'test_end_state')
lock_secrethash = sha3(lock_secret)
lock = HashTimeLockState(
lock_amount,
lock_expiration,
lock_secrethash,
)
mediated_transfer = make_receive_transfer_mediated(
channel_state=channel_state,
privkey=pkey,
nonce=1,
transferred_amount=0,
lock=lock,
)
from_route = factories.route_from_channel(channel_state)
init_target = ActionInitTarget(
from_route,
mediated_transfer,
)
node.state_transition(chain_state, init_target)
closed_block_number = open_block_number + 10
channel_close_state_change = ContractReceiveChannelClosed(
factories.make_transaction_hash(),
channel_state.partner_state.address,
token_network_state.address,
channel_state.identifier,
closed_block_number,
)
channel_closed_iteration = token_network.state_transition(
payment_network_identifier,
channel_new_iteration.new_state,
channel_close_state_change,
pseudo_random_generator,
closed_block_number,
)
settle_block_number = closed_block_number + channel_state.settle_timeout + 1
channel_settled_state_change = ContractReceiveChannelSettled(
factories.make_transaction_hash(),
token_network_state.address,
channel_state.identifier,
settle_block_number,
)
channel_settled_iteration = token_network.state_transition(
payment_network_identifier,
channel_closed_iteration.new_state,
channel_settled_state_change,
pseudo_random_generator,
closed_block_number,
)
token_network_state_after_settle = channel_settled_iteration.new_state
ids_to_channels = token_network_state_after_settle.channelidentifiers_to_channels
assert len(ids_to_channels) == 1
assert channel_state.identifier in ids_to_channels
unlock_blocknumber = settle_block_number + 5
channel_batch_unlock_state_change = ContractReceiveChannelBatchUnlock(
transaction_hash=factories.make_transaction_hash(),
token_network_identifier=token_network_state.address,
participant=our_address,
partner=address,
locksroot=lock_secrethash,
unlocked_amount=lock_amount,
returned_tokens=0,
block_number=closed_block_number + 1,
)
channel_unlock_iteration = token_network.state_transition(
payment_network_identifier,
channel_settled_iteration.new_state,
channel_batch_unlock_state_change,
pseudo_random_generator,
unlock_blocknumber,
)
token_network_state_after_unlock = channel_unlock_iteration.new_state
ids_to_channels = token_network_state_after_unlock.channelidentifiers_to_channels
assert len(ids_to_channels) == 0
def test_mediator_clear_pairs_after_batch_unlock(chain_state,
token_network_state,
our_address,
channel_properties):
""" Regression test for https://github.com/raiden-network/raiden/issues/2932
The mediator must also clear the transfer pairs once a ReceiveBatchUnlock where
he is a participant is received.
"""
open_block_number = 10
open_block_hash = factories.make_block_hash()
properties, pkey = channel_properties
address = properties.partner_state.address
channel_state = factories.create(properties)
channel_new_state_change = ContractReceiveChannelNew(
transaction_hash=factories.make_transaction_hash(),
channel_state=channel_state,
block_number=open_block_number,
block_hash=open_block_hash,
)
channel_new_iteration = token_network.state_transition(
token_network_state=token_network_state,
state_change=channel_new_state_change,
block_number=open_block_number,
block_hash=open_block_hash,
)
lock_amount = 30
lock_expiration = 20
lock_secret = sha3(b"test_end_state")
lock_secrethash = sha3(lock_secret)
lock = HashTimeLockState(lock_amount, lock_expiration, lock_secrethash)
mediated_transfer = make_receive_transfer_mediated(
channel_state=channel_state,
privkey=pkey,
nonce=1,
transferred_amount=0,
lock=lock)
from_route = factories.make_route_from_channel(channel_state)
init_mediator = ActionInitMediator(routes=[from_route],
from_route=from_route,
from_transfer=mediated_transfer)
node.state_transition(chain_state, init_mediator, None)
closed_block_number = open_block_number + 10
closed_block_hash = factories.make_block_hash()
channel_close_state_change = ContractReceiveChannelClosed(
transaction_hash=factories.make_transaction_hash(),
transaction_from=channel_state.partner_state.address,
canonical_identifier=channel_state.canonical_identifier,
block_number=closed_block_number,
block_hash=closed_block_hash,
)
channel_closed_iteration = token_network.state_transition(
token_network_state=channel_new_iteration.new_state,
state_change=channel_close_state_change,
block_number=closed_block_number,
block_hash=closed_block_hash,
)
settle_block_number = closed_block_number + channel_state.settle_timeout + 1
channel_settled_state_change = ContractReceiveChannelSettled(
transaction_hash=factories.make_transaction_hash(),
canonical_identifier=channel_state.canonical_identifier,
block_number=settle_block_number,
block_hash=factories.make_block_hash(),
our_onchain_locksroot=factories.make_32bytes(),
partner_onchain_locksroot=EMPTY_MERKLE_ROOT,
)
channel_settled_iteration = token_network.state_transition(
token_network_state=channel_closed_iteration.new_state,
state_change=channel_settled_state_change,
block_number=closed_block_number,
block_hash=closed_block_hash,
)
token_network_state_after_settle = channel_settled_iteration.new_state
ids_to_channels = token_network_state_after_settle.channelidentifiers_to_channels
assert len(ids_to_channels) == 1
assert channel_state.identifier in ids_to_channels
block_number = closed_block_number + 1
channel_batch_unlock_state_change = ContractReceiveChannelBatchUnlock(
transaction_hash=factories.make_transaction_hash(),
canonical_identifier=channel_state.canonical_identifier,
participant=address,
partner=our_address,
locksroot=lock_secrethash,
unlocked_amount=lock_amount,
returned_tokens=0,
block_number=block_number,
block_hash=factories.make_block_hash(),
)
channel_unlock_iteration = node.state_transition(
chain_state=chain_state,
state_change=channel_batch_unlock_state_change,
storage=None)
chain_state = channel_unlock_iteration.new_state
token_network_state = views.get_token_network_by_identifier(
chain_state=chain_state, token_network_id=token_network_state.address)
ids_to_channels = token_network_state.channelidentifiers_to_channels
assert len(ids_to_channels) == 0
# Make sure that all is fine in the next block
block = Block(block_number=block_number + 1,
gas_limit=1,
block_hash=factories.make_transaction_hash())
iteration = node.state_transition(chain_state=chain_state,
state_change=block,
storage=None)
assert iteration.new_state
# Make sure that mediator task was cleared during the next block processing
# since the channel was removed
mediator_task = chain_state.payment_mapping.secrethashes_to_task.get(
lock_secrethash)
assert not mediator_task
def test_multiple_channel_states(chain_state, token_network_state,
channel_properties):
open_block_number = 10
open_block_hash = factories.make_block_hash()
pseudo_random_generator = random.Random()
properties, pkey = channel_properties
channel_state = factories.create(properties)
channel_new_state_change = ContractReceiveChannelNew(
transaction_hash=factories.make_transaction_hash(),
channel_state=channel_state,
block_number=open_block_number,
block_hash=open_block_hash,
)
channel_new_iteration = token_network.state_transition(
token_network_state=token_network_state,
state_change=channel_new_state_change,
block_number=open_block_number,
block_hash=open_block_hash,
pseudo_random_generator=pseudo_random_generator,
)
lock_amount = 30
lock_expiration = 20
lock_secret = keccak(b"test_end_state")
lock_secrethash = sha256(lock_secret).digest()
lock = HashTimeLockState(lock_amount, lock_expiration, lock_secrethash)
mediated_transfer = make_receive_transfer_mediated(
channel_state=channel_state,
privkey=pkey,
nonce=1,
transferred_amount=0,
lock=lock)
from_hop = factories.make_hop_from_channel(channel_state)
init_target = ActionInitTarget(
from_hop=from_hop,
transfer=mediated_transfer,
balance_proof=mediated_transfer.balance_proof,
sender=mediated_transfer.balance_proof.sender, # pylint: disable=no-member
)
node.state_transition(chain_state, init_target)
closed_block_number = open_block_number + 10
closed_block_hash = factories.make_block_hash()
channel_close_state_change = ContractReceiveChannelClosed(
transaction_hash=factories.make_transaction_hash(),
transaction_from=channel_state.partner_state.address,
canonical_identifier=channel_state.canonical_identifier,
block_number=closed_block_number,
block_hash=closed_block_hash,
)
channel_closed_iteration = token_network.state_transition(
token_network_state=channel_new_iteration.new_state,
state_change=channel_close_state_change,
block_number=closed_block_number,
block_hash=closed_block_hash,
pseudo_random_generator=pseudo_random_generator,
)
settle_block_number = closed_block_number + channel_state.settle_timeout + 1
channel_settled_state_change = ContractReceiveChannelSettled(
transaction_hash=factories.make_transaction_hash(),
canonical_identifier=channel_state.canonical_identifier,
block_number=settle_block_number,
block_hash=factories.make_block_hash(),
our_onchain_locksroot=factories.make_32bytes(),
partner_onchain_locksroot=LOCKSROOT_OF_NO_LOCKS,
)
channel_settled_iteration = token_network.state_transition(
token_network_state=channel_closed_iteration.new_state,
state_change=channel_settled_state_change,
block_number=closed_block_number,
block_hash=closed_block_hash,
pseudo_random_generator=pseudo_random_generator,
)
token_network_state_after_settle = channel_settled_iteration.new_state
ids_to_channels = token_network_state_after_settle.channelidentifiers_to_channels
assert len(ids_to_channels) == 1
assert channel_state.identifier in ids_to_channels
# Create new channel while the previous one is pending unlock
new_channel_properties = factories.create_properties(
factories.NettingChannelStateProperties(
canonical_identifier=factories.make_canonical_identifier()),
defaults=properties,
)
new_channel_state = factories.create(new_channel_properties)
channel_new_state_change = ContractReceiveChannelNew(
transaction_hash=factories.make_transaction_hash(),
channel_state=new_channel_state,
block_number=closed_block_number + 1,
block_hash=factories.make_block_hash(),
)
channel_new_iteration = token_network.state_transition(
token_network_state=token_network_state,
state_change=channel_new_state_change,
block_number=open_block_number,
block_hash=open_block_hash,
pseudo_random_generator=pseudo_random_generator,
)
token_network_state_after_new_open = channel_new_iteration.new_state
ids_to_channels = token_network_state_after_new_open.channelidentifiers_to_channels
assert len(ids_to_channels) == 2
assert channel_state.identifier in ids_to_channels
def test_channel_data_removed_after_unlock(chain_state, token_network_state,
our_address, channel_properties):
open_block_number = 10
open_block_hash = factories.make_block_hash()
pseudo_random_generator = random.Random()
properties, pkey = channel_properties
address = properties.partner_state.address
channel_state = factories.create(properties)
channel_new_state_change = ContractReceiveChannelNew(
transaction_hash=factories.make_transaction_hash(),
channel_state=channel_state,
block_number=open_block_number,
block_hash=open_block_hash,
)
channel_new_iteration = token_network.state_transition(
token_network_state=token_network_state,
state_change=channel_new_state_change,
block_number=open_block_number,
block_hash=open_block_hash,
pseudo_random_generator=pseudo_random_generator,
)
lock_amount = 30
lock_expiration = 20
lock_secret = keccak(b"test_end_state")
lock_secrethash = sha256(lock_secret).digest()
lock = HashTimeLockState(lock_amount, lock_expiration, lock_secrethash)
mediated_transfer = make_receive_transfer_mediated(
channel_state=channel_state,
privkey=pkey,
nonce=1,
transferred_amount=0,
lock=lock)
from_hop = factories.make_hop_from_channel(channel_state)
init_target = ActionInitTarget(
sender=mediated_transfer.balance_proof.sender, # pylint: disable=no-member
balance_proof=mediated_transfer.balance_proof,
from_hop=from_hop,
transfer=mediated_transfer,
)
node.state_transition(chain_state, init_target)
closed_block_number = open_block_number + 10
closed_block_hash = factories.make_block_hash()
channel_close_state_change = ContractReceiveChannelClosed(
transaction_hash=factories.make_transaction_hash(),
transaction_from=channel_state.partner_state.address,
canonical_identifier=channel_state.canonical_identifier,
block_number=closed_block_number,
block_hash=closed_block_hash,
)
channel_closed_iteration = token_network.state_transition(
token_network_state=channel_new_iteration.new_state,
state_change=channel_close_state_change,
block_number=closed_block_number,
block_hash=closed_block_hash,
pseudo_random_generator=pseudo_random_generator,
)
channel_state_after_closed = channel_closed_iteration.new_state.channelidentifiers_to_channels[
channel_state.identifier]
settle_block_number = closed_block_number + channel_state.settle_timeout + 1
channel_settled_state_change = ContractReceiveChannelSettled(
transaction_hash=factories.make_transaction_hash(),
canonical_identifier=channel_state.canonical_identifier,
block_number=settle_block_number,
block_hash=factories.make_block_hash(),
our_onchain_locksroot=compute_locksroot(
channel_state_after_closed.our_state.pending_locks),
partner_onchain_locksroot=compute_locksroot(
channel_state_after_closed.partner_state.pending_locks),
)
channel_settled_iteration = token_network.state_transition(
token_network_state=channel_closed_iteration.new_state,
state_change=channel_settled_state_change,
block_number=closed_block_number,
block_hash=closed_block_hash,
pseudo_random_generator=pseudo_random_generator,
)
token_network_state_after_settle = channel_settled_iteration.new_state
ids_to_channels = token_network_state_after_settle.channelidentifiers_to_channels
assert len(ids_to_channels) == 1
assert channel_state.identifier in ids_to_channels
unlock_blocknumber = settle_block_number + 5
channel_batch_unlock_state_change = ContractReceiveChannelBatchUnlock(
transaction_hash=factories.make_transaction_hash(),
canonical_identifier=channel_state.canonical_identifier,
receiver=our_address,
sender=address,
locksroot=compute_locksroot(PendingLocksState([bytes(lock.encoded)])),
unlocked_amount=lock_amount,
returned_tokens=0,
block_number=closed_block_number + 1,
block_hash=factories.make_block_hash(),
)
channel_unlock_iteration = token_network.state_transition(
token_network_state=channel_settled_iteration.new_state,
state_change=channel_batch_unlock_state_change,
block_number=unlock_blocknumber,
block_hash=factories.make_block_hash(),
pseudo_random_generator=pseudo_random_generator,
)
token_network_state_after_unlock = channel_unlock_iteration.new_state
ids_to_channels = token_network_state_after_unlock.channelidentifiers_to_channels
assert len(ids_to_channels) == 0
def test_channel_settle_must_properly_cleanup(channel_properties):
open_block_number = 10
open_block_hash = factories.make_block_hash()
pseudo_random_generator = random.Random()
token_network_address = factories.make_address()
token_id = factories.make_address()
token_network_state = TokenNetworkState(
address=token_network_address,
token_address=token_id,
network_graph=TokenNetworkGraphState(token_network_address),
)
properties, _ = channel_properties
channel_state = factories.create(properties)
channel_new_state_change = ContractReceiveChannelNew(
transaction_hash=factories.make_transaction_hash(),
channel_state=channel_state,
block_number=open_block_number,
block_hash=open_block_hash,
)
channel_new_iteration = token_network.state_transition(
token_network_state=token_network_state,
state_change=channel_new_state_change,
block_number=open_block_number,
block_hash=open_block_hash,
pseudo_random_generator=pseudo_random_generator,
)
closed_block_number = open_block_number + 10
closed_block_hash = factories.make_block_hash()
channel_close_state_change = ContractReceiveChannelClosed(
transaction_hash=factories.make_transaction_hash(),
transaction_from=channel_state.partner_state.address,
canonical_identifier=channel_state.canonical_identifier,
block_number=closed_block_number,
block_hash=closed_block_hash,
)
channel_closed_iteration = token_network.state_transition(
token_network_state=channel_new_iteration.new_state,
state_change=channel_close_state_change,
block_number=closed_block_number,
block_hash=closed_block_hash,
pseudo_random_generator=pseudo_random_generator,
)
settle_block_number = closed_block_number + channel_state.settle_timeout + 1
channel_settled_state_change = ContractReceiveChannelSettled(
transaction_hash=factories.make_transaction_hash(),
canonical_identifier=channel_state.canonical_identifier,
block_number=settle_block_number,
block_hash=factories.make_block_hash(),
our_onchain_locksroot=LOCKSROOT_OF_NO_LOCKS,
partner_onchain_locksroot=LOCKSROOT_OF_NO_LOCKS,
)
channel_settled_iteration = token_network.state_transition(
token_network_state=channel_closed_iteration.new_state,
state_change=channel_settled_state_change,
block_number=closed_block_number,
block_hash=closed_block_hash,
pseudo_random_generator=pseudo_random_generator,
)
token_network_state_after_settle = channel_settled_iteration.new_state
ids_to_channels = token_network_state_after_settle.channelidentifiers_to_channels
assert channel_state.identifier not in ids_to_channels
def test_mediator_clear_pairs_after_batch_unlock(
chain_state,
token_network_state,
our_address,
):
""" Regression test for https://github.com/raiden-network/raiden/issues/2932
The mediator must also clear the transfer pairs once a ReceiveBatchUnlock where
he is a participant is received.
"""
open_block_number = 10
pseudo_random_generator = random.Random()
pkey, address = factories.make_privkey_address()
amount = 30
our_balance = amount + 50
channel_state = factories.make_channel(
our_balance=our_balance,
our_address=our_address,
partner_balance=our_balance,
partner_address=address,
token_network_identifier=token_network_state.address,
)
payment_network_identifier = factories.make_payment_network_identifier()
channel_new_state_change = ContractReceiveChannelNew(
factories.make_transaction_hash(),
token_network_state.address,
channel_state,
open_block_number,
)
channel_new_iteration = token_network.state_transition(
payment_network_identifier,
token_network_state,
channel_new_state_change,
pseudo_random_generator,
open_block_number,
)
lock_amount = 30
lock_expiration = 20
lock_secret = sha3(b'test_end_state')
lock_secrethash = sha3(lock_secret)
lock = HashTimeLockState(
lock_amount,
lock_expiration,
lock_secrethash,
)
mediated_transfer = make_receive_transfer_mediated(
channel_state=channel_state,
privkey=pkey,
nonce=1,
transferred_amount=0,
lock=lock,
)
from_route = factories.route_from_channel(channel_state)
init_mediator = ActionInitMediator(
routes=[from_route],
from_route=from_route,
from_transfer=mediated_transfer,
)
node.state_transition(chain_state, init_mediator)
closed_block_number = open_block_number + 10
channel_close_state_change = ContractReceiveChannelClosed(
factories.make_transaction_hash(),
channel_state.partner_state.address,
token_network_state.address,
channel_state.identifier,
closed_block_number,
)
channel_closed_iteration = token_network.state_transition(
payment_network_identifier,
channel_new_iteration.new_state,
channel_close_state_change,
pseudo_random_generator,
closed_block_number,
)
settle_block_number = closed_block_number + channel_state.settle_timeout + 1
channel_settled_state_change = ContractReceiveChannelSettled(
factories.make_transaction_hash(),
token_network_state.address,
channel_state.identifier,
settle_block_number,
)
channel_settled_iteration = token_network.state_transition(
payment_network_identifier,
channel_closed_iteration.new_state,
channel_settled_state_change,
pseudo_random_generator,
closed_block_number,
)
token_network_state_after_settle = channel_settled_iteration.new_state
ids_to_channels = token_network_state_after_settle.channelidentifiers_to_channels
assert len(ids_to_channels) == 1
assert channel_state.identifier in ids_to_channels
block_number = closed_block_number + 1
channel_batch_unlock_state_change = ContractReceiveChannelBatchUnlock(
transaction_hash=factories.make_transaction_hash(),
token_network_identifier=token_network_state.address,
participant=our_address,
partner=address,
locksroot=lock_secrethash,
unlocked_amount=lock_amount,
returned_tokens=0,
block_number=block_number,
)
channel_unlock_iteration = node.state_transition(
chain_state=chain_state,
state_change=channel_batch_unlock_state_change,
)
chain_state = channel_unlock_iteration.new_state
token_network_state = views.get_token_network_by_identifier(
chain_state=chain_state,
token_network_id=token_network_state.address,
)
ids_to_channels = token_network_state.channelidentifiers_to_channels
assert len(ids_to_channels) == 0
# Make sure that all is fine in the next block
block = Block(
block_number=block_number + 1,
gas_limit=1,
block_hash=factories.make_transaction_hash(),
)
iteration = node.state_transition(
chain_state=chain_state,
state_change=block,
)
assert iteration.new_state
# Make sure that mediator task was cleared during the next block processing
# since the channel was removed
mediator_task = chain_state.payment_mapping.secrethashes_to_task.get(
lock_secrethash)
assert not mediator_task
def test_channel_data_removed_after_unlock(chain_state, token_network_state,
our_address, channel_properties):
open_block_number = 10
open_block_hash = factories.make_block_hash()
properties, pkey = channel_properties
address = properties.partner_state.address
channel_state = factories.create(properties)
channel_new_state_change = ContractReceiveChannelNew(
transaction_hash=factories.make_transaction_hash(),
channel_state=channel_state,
block_number=open_block_number,
block_hash=open_block_hash,
)
channel_new_iteration = token_network.state_transition(
token_network_state=token_network_state,
state_change=channel_new_state_change,
block_number=open_block_number,
block_hash=open_block_hash,
)
lock_amount = 30
lock_expiration = 20
lock_secret = sha3(b"test_end_state")
lock_secrethash = sha3(lock_secret)
lock = HashTimeLockState(lock_amount, lock_expiration, lock_secrethash)
mediated_transfer = make_receive_transfer_mediated(
channel_state=channel_state,
privkey=pkey,
nonce=1,
transferred_amount=0,
lock=lock)
from_route = factories.make_route_from_channel(channel_state)
init_target = ActionInitTarget(from_route, mediated_transfer)
node.state_transition(chain_state, init_target)
closed_block_number = open_block_number + 10
closed_block_hash = factories.make_block_hash()
channel_close_state_change = ContractReceiveChannelClosed(
transaction_hash=factories.make_transaction_hash(),
transaction_from=channel_state.partner_state.address,
canonical_identifier=channel_state.canonical_identifier,
block_number=closed_block_number,
block_hash=closed_block_hash,
)
channel_closed_iteration = token_network.state_transition(
token_network_state=channel_new_iteration.new_state,
state_change=channel_close_state_change,
block_number=closed_block_number,
block_hash=closed_block_hash,
)
settle_block_number = closed_block_number + channel_state.settle_timeout + 1
channel_settled_state_change = ContractReceiveChannelSettled(
transaction_hash=factories.make_transaction_hash(),
canonical_identifier=channel_state.canonical_identifier,
block_number=settle_block_number,
block_hash=factories.make_block_hash(),
our_onchain_locksroot=factories.make_32bytes(),
partner_onchain_locksroot=EMPTY_MERKLE_ROOT,
)
channel_settled_iteration = token_network.state_transition(
token_network_state=channel_closed_iteration.new_state,
state_change=channel_settled_state_change,
block_number=closed_block_number,
block_hash=closed_block_hash,
)
token_network_state_after_settle = channel_settled_iteration.new_state
ids_to_channels = token_network_state_after_settle.channelidentifiers_to_channels
assert len(ids_to_channels) == 1
assert channel_state.identifier in ids_to_channels
unlock_blocknumber = settle_block_number + 5
channel_batch_unlock_state_change = ContractReceiveChannelBatchUnlock(
transaction_hash=factories.make_transaction_hash(),
canonical_identifier=channel_state.canonical_identifier,
participant=our_address,
partner=address,
locksroot=lock_secrethash,
unlocked_amount=lock_amount,
returned_tokens=0,
block_number=closed_block_number + 1,
block_hash=factories.make_block_hash(),
)
channel_unlock_iteration = token_network.state_transition(
token_network_state=channel_settled_iteration.new_state,
state_change=channel_batch_unlock_state_change,
block_number=unlock_blocknumber,
block_hash=factories.make_block_hash(),
)
token_network_state_after_unlock = channel_unlock_iteration.new_state
ids_to_channels = token_network_state_after_unlock.channelidentifiers_to_channels
assert len(ids_to_channels) == 0
def test_routing_updates(token_network_state, our_address, channel_properties):
open_block_number = 10
properties, _ = channel_properties
address1 = properties.partner_state.address
address2 = factories.make_address()
address3 = factories.make_address()
pseudo_random_generator = random.Random()
channel_state = factories.create(properties)
open_block_hash = factories.make_block_hash()
# create a new channel as participant, check graph update
channel_new_state_change = ContractReceiveChannelNew(
transaction_hash=factories.make_transaction_hash(),
channel_state=channel_state,
block_number=open_block_number,
block_hash=open_block_hash,
)
channel_new_iteration1 = token_network.state_transition(
token_network_state=token_network_state,
state_change=channel_new_state_change,
block_number=open_block_number,
block_hash=open_block_hash,
pseudo_random_generator=pseudo_random_generator,
)
graph_state = channel_new_iteration1.new_state.network_graph
assert channel_state.identifier in graph_state.channel_identifier_to_participants
assert len(graph_state.channel_identifier_to_participants) == 1
assert graph_state.network[our_address][address1] is not None
assert len(graph_state.network.edges()) == 1
# create a new channel without being participant, check graph update
new_channel_identifier = factories.make_channel_identifier()
channel_new_state_change = ContractReceiveRouteNew(
transaction_hash=factories.make_transaction_hash(),
canonical_identifier=factories.make_canonical_identifier(
token_network_address=token_network_state.address,
channel_identifier=new_channel_identifier,
),
participant1=address2,
participant2=address3,
block_number=open_block_number,
block_hash=open_block_hash,
)
channel_new_iteration2 = token_network.state_transition(
token_network_state=channel_new_iteration1.new_state,
state_change=channel_new_state_change,
block_number=open_block_number + 10,
block_hash=factories.make_block_hash(),
pseudo_random_generator=pseudo_random_generator,
)
graph_state = channel_new_iteration2.new_state.network_graph
assert channel_state.identifier in graph_state.channel_identifier_to_participants
assert new_channel_identifier in graph_state.channel_identifier_to_participants
assert len(graph_state.channel_identifier_to_participants) == 2
assert graph_state.network[our_address][address1] is not None
assert graph_state.network[address2][address3] is not None
assert len(graph_state.network.edges()) == 2
# close the channel the node is a participant of, check edge is removed from graph
closed_block_number = open_block_number + 20
closed_block_hash = factories.make_block_hash()
channel_close_state_change1 = ContractReceiveChannelClosed(
transaction_hash=factories.make_transaction_hash(),
transaction_from=channel_state.partner_state.address,
canonical_identifier=channel_state.canonical_identifier,
block_number=closed_block_number,
block_hash=closed_block_hash,
)
channel_closed_iteration1 = token_network.state_transition(
token_network_state=channel_new_iteration2.new_state,
state_change=channel_close_state_change1,
block_number=closed_block_number,
block_hash=closed_block_hash,
pseudo_random_generator=pseudo_random_generator,
)
# Check that a second ContractReceiveChannelClosed events is handled properly
# This might have been sent from the other participant of the channel
# See issue #2449
channel_close_state_change2 = ContractReceiveChannelClosed(
transaction_hash=factories.make_transaction_hash(),
transaction_from=channel_state.our_state.address,
canonical_identifier=channel_state.canonical_identifier,
block_number=closed_block_number,
block_hash=closed_block_hash,
)
channel_closed_iteration2 = token_network.state_transition(
token_network_state=channel_closed_iteration1.new_state,
state_change=channel_close_state_change2,
block_number=closed_block_number,
block_hash=closed_block_hash,
pseudo_random_generator=pseudo_random_generator,
)
graph_state = channel_closed_iteration2.new_state.network_graph
assert channel_state.identifier not in graph_state.channel_identifier_to_participants
assert new_channel_identifier in graph_state.channel_identifier_to_participants
assert len(graph_state.channel_identifier_to_participants) == 1
assert graph_state.network[address2][address3] is not None
assert len(graph_state.network.edges()) == 1
# close the channel the node is not a participant of, check edge is removed from graph
channel_close_state_change3 = ContractReceiveRouteClosed(
transaction_hash=factories.make_transaction_hash(),
canonical_identifier=factories.make_canonical_identifier(
token_network_address=token_network_state.address,
channel_identifier=new_channel_identifier,
),
block_number=closed_block_number,
block_hash=closed_block_hash,
)
channel_closed_iteration3 = token_network.state_transition(
token_network_state=channel_closed_iteration2.new_state,
state_change=channel_close_state_change3,
block_number=closed_block_number + 10,
block_hash=factories.make_block_hash(),
pseudo_random_generator=pseudo_random_generator,
)
# Check that a second ContractReceiveRouteClosed events is handled properly.
# This might have been sent from the second participant of the channel
# See issue #2449
closed_block_plus_10_hash = factories.make_block_hash()
channel_close_state_change4 = ContractReceiveRouteClosed(
transaction_hash=factories.make_transaction_hash(),
canonical_identifier=factories.make_canonical_identifier(
token_network_address=token_network_state.address,
channel_identifier=new_channel_identifier,
),
block_number=closed_block_number + 10,
block_hash=closed_block_plus_10_hash,
)
channel_closed_iteration4 = token_network.state_transition(
token_network_state=channel_closed_iteration3.new_state,
state_change=channel_close_state_change4,
block_number=closed_block_number + 10,
block_hash=closed_block_plus_10_hash,
pseudo_random_generator=pseudo_random_generator,
)
graph_state = channel_closed_iteration4.new_state.network_graph
assert channel_state.identifier not in graph_state.channel_identifier_to_participants
assert new_channel_identifier not in graph_state.channel_identifier_to_participants
assert len(graph_state.channel_identifier_to_participants) == 0
assert len(graph_state.network.edges()) == 0
def test_channel_settle_must_properly_cleanup(channel_properties):
open_block_number = 10
open_block_hash = factories.make_block_hash()
token_network_id = factories.make_address()
token_id = factories.make_address()
token_network_state = TokenNetworkState(token_network_id, token_id)
properties, _ = channel_properties
channel_state = factories.create(properties)
channel_new_state_change = ContractReceiveChannelNew(
transaction_hash=factories.make_transaction_hash(),
channel_state=channel_state,
block_number=open_block_number,
block_hash=open_block_hash,
)
channel_new_iteration = token_network.state_transition(
token_network_state=token_network_state,
state_change=channel_new_state_change,
block_number=open_block_number,
block_hash=open_block_hash,
)
closed_block_number = open_block_number + 10
closed_block_hash = factories.make_block_hash()
channel_close_state_change = ContractReceiveChannelClosed(
transaction_hash=factories.make_transaction_hash(),
transaction_from=channel_state.partner_state.address,
canonical_identifier=channel_state.canonical_identifier,
block_number=closed_block_number,
block_hash=closed_block_hash,
)
channel_closed_iteration = token_network.state_transition(
token_network_state=channel_new_iteration.new_state,
state_change=channel_close_state_change,
block_number=closed_block_number,
block_hash=closed_block_hash,
)
settle_block_number = closed_block_number + channel_state.settle_timeout + 1
channel_settled_state_change = ContractReceiveChannelSettled(
transaction_hash=factories.make_transaction_hash(),
canonical_identifier=channel_state.canonical_identifier,
block_number=settle_block_number,
block_hash=factories.make_block_hash(),
our_onchain_locksroot=EMPTY_MERKLE_ROOT,
partner_onchain_locksroot=EMPTY_MERKLE_ROOT,
)
channel_settled_iteration = token_network.state_transition(
token_network_state=channel_closed_iteration.new_state,
state_change=channel_settled_state_change,
block_number=closed_block_number,
block_hash=closed_block_hash,
)
token_network_state_after_settle = channel_settled_iteration.new_state
ids_to_channels = token_network_state_after_settle.channelidentifiers_to_channels
assert channel_state.identifier not in ids_to_channels
def test_mediator_clear_pairs_after_batch_unlock(chain_state,
token_network_state,
our_address,
channel_properties):
""" Regression test for https://github.com/raiden-network/raiden/issues/2932
The mediator must also clear the transfer pairs once a ReceiveBatchUnlock where
he is a participant is received.
"""
open_block_number = 10
open_block_hash = factories.make_block_hash()
pseudo_random_generator = random.Random()
properties, pkey = channel_properties
address = properties.partner_state.address
channel_state = factories.create(properties)
channel_new_state_change = ContractReceiveChannelNew(
transaction_hash=factories.make_transaction_hash(),
channel_state=channel_state,
block_number=open_block_number,
block_hash=open_block_hash,
)
channel_new_iteration = token_network.state_transition(
token_network_state=token_network_state,
state_change=channel_new_state_change,
block_number=open_block_number,
block_hash=open_block_hash,
pseudo_random_generator=pseudo_random_generator,
)
lock_amount = 30
lock_expiration = 20
lock_secret = keccak(b"test_end_state")
lock_secrethash = sha256(lock_secret).digest()
lock = HashTimeLockState(lock_amount, lock_expiration, lock_secrethash)
mediated_transfer = make_receive_transfer_mediated(
channel_state=channel_state,
privkey=pkey,
nonce=1,
transferred_amount=0,
lock=lock)
route_state = RouteState(
route=[
channel_state.our_state.address,
channel_state.partner_state.address
],
forward_channel_id=channel_state.canonical_identifier.
channel_identifier,
)
from_hop = factories.make_hop_from_channel(channel_state)
init_mediator = ActionInitMediator(
route_states=[route_state],
from_hop=from_hop,
from_transfer=mediated_transfer,
balance_proof=mediated_transfer.balance_proof,
sender=mediated_transfer.balance_proof.sender, # pylint: disable=no-member
)
node.state_transition(chain_state, init_mediator)
closed_block_number = open_block_number + 10
closed_block_hash = factories.make_block_hash()
channel_close_state_change = ContractReceiveChannelClosed(
transaction_hash=factories.make_transaction_hash(),
transaction_from=channel_state.partner_state.address,
canonical_identifier=channel_state.canonical_identifier,
block_number=closed_block_number,
block_hash=closed_block_hash,
)
channel_closed_iteration = token_network.state_transition(
token_network_state=channel_new_iteration.new_state,
state_change=channel_close_state_change,
block_number=closed_block_number,
block_hash=closed_block_hash,
pseudo_random_generator=pseudo_random_generator,
)
settle_block_number = closed_block_number + channel_state.settle_timeout + 1
channel_settled_state_change = ContractReceiveChannelSettled(
transaction_hash=factories.make_transaction_hash(),
canonical_identifier=channel_state.canonical_identifier,
block_number=settle_block_number,
block_hash=factories.make_block_hash(),
our_onchain_locksroot=factories.make_32bytes(),
partner_onchain_locksroot=LOCKSROOT_OF_NO_LOCKS,
)
channel_settled_iteration = token_network.state_transition(
token_network_state=channel_closed_iteration.new_state,
state_change=channel_settled_state_change,
block_number=closed_block_number,
block_hash=closed_block_hash,
pseudo_random_generator=pseudo_random_generator,
)
token_network_state_after_settle = channel_settled_iteration.new_state
ids_to_channels = token_network_state_after_settle.channelidentifiers_to_channels
assert len(ids_to_channels) == 1
assert channel_state.identifier in ids_to_channels
block_number = closed_block_number + 1
channel_batch_unlock_state_change = ContractReceiveChannelBatchUnlock(
transaction_hash=factories.make_transaction_hash(),
canonical_identifier=channel_state.canonical_identifier,
receiver=address,
sender=our_address,
locksroot=compute_locksroot(PendingLocksState([bytes(lock.encoded)])),
unlocked_amount=lock_amount,
returned_tokens=0,
block_number=block_number,
block_hash=factories.make_block_hash(),
)
channel_unlock_iteration = node.state_transition(
chain_state=chain_state,
state_change=channel_batch_unlock_state_change)
chain_state = channel_unlock_iteration.new_state
token_network_state = views.get_token_network_by_address(
chain_state=chain_state,
token_network_address=token_network_state.address)
ids_to_channels = token_network_state.channelidentifiers_to_channels
assert len(ids_to_channels) == 0
# Make sure that all is fine in the next block
block = Block(block_number=block_number + 1,
gas_limit=1,
block_hash=factories.make_transaction_hash())
iteration = node.state_transition(chain_state=chain_state,
state_change=block)
assert iteration.new_state
# Make sure that mediator task was cleared during the next block processing
# since the channel was removed
mediator_task = chain_state.payment_mapping.secrethashes_to_task.get(
lock_secrethash)
assert not mediator_task
def test_multiple_channel_states(chain_state, token_network_state,
channel_properties):
open_block_number = 10
open_block_hash = factories.make_block_hash()
properties, pkey = channel_properties
channel_state = factories.create(properties)
channel_new_state_change = ContractReceiveChannelNew(
transaction_hash=factories.make_transaction_hash(),
channel_state=channel_state,
block_number=open_block_number,
block_hash=open_block_hash,
)
channel_new_iteration = token_network.state_transition(
token_network_state=token_network_state,
state_change=channel_new_state_change,
block_number=open_block_number,
block_hash=open_block_hash,
)
lock_amount = 30
lock_expiration = 20
lock_secret = sha3(b"test_end_state")
lock_secrethash = sha3(lock_secret)
lock = HashTimeLockState(lock_amount, lock_expiration, lock_secrethash)
mediated_transfer = make_receive_transfer_mediated(
channel_state=channel_state,
privkey=pkey,
nonce=1,
transferred_amount=0,
lock=lock)
from_route = factories.make_route_from_channel(channel_state)
init_target = ActionInitTarget(from_route, mediated_transfer)
node.state_transition(chain_state, init_target, None)
closed_block_number = open_block_number + 10
closed_block_hash = factories.make_block_hash()
channel_close_state_change = ContractReceiveChannelClosed(
transaction_hash=factories.make_transaction_hash(),
transaction_from=channel_state.partner_state.address,
canonical_identifier=channel_state.canonical_identifier,
block_number=closed_block_number,
block_hash=closed_block_hash,
)
channel_closed_iteration = token_network.state_transition(
token_network_state=channel_new_iteration.new_state,
state_change=channel_close_state_change,
block_number=closed_block_number,
block_hash=closed_block_hash,
)
settle_block_number = closed_block_number + channel_state.settle_timeout + 1
channel_settled_state_change = ContractReceiveChannelSettled(
transaction_hash=factories.make_transaction_hash(),
canonical_identifier=channel_state.canonical_identifier,
block_number=settle_block_number,
block_hash=factories.make_block_hash(),
our_onchain_locksroot=factories.make_32bytes(),
partner_onchain_locksroot=EMPTY_MERKLE_ROOT,
)
channel_settled_iteration = token_network.state_transition(
token_network_state=channel_closed_iteration.new_state,
state_change=channel_settled_state_change,
block_number=closed_block_number,
block_hash=closed_block_hash,
)
token_network_state_after_settle = channel_settled_iteration.new_state
ids_to_channels = token_network_state_after_settle.channelidentifiers_to_channels
assert len(ids_to_channels) == 1
assert channel_state.identifier in ids_to_channels
# Create new channel while the previous one is pending unlock
new_channel_properties = factories.create_properties(
factories.NettingChannelStateProperties(
canonical_identifier=factories.make_canonical_identifier()),
defaults=properties,
)
new_channel_state = factories.create(new_channel_properties)
channel_new_state_change = ContractReceiveChannelNew(
transaction_hash=factories.make_transaction_hash(),
channel_state=new_channel_state,
block_number=closed_block_number + 1,
block_hash=factories.make_block_hash(),
)
channel_new_iteration = token_network.state_transition(
token_network_state=token_network_state,
state_change=channel_new_state_change,
block_number=open_block_number,
block_hash=open_block_hash,
)
token_network_state_after_new_open = channel_new_iteration.new_state
ids_to_channels = token_network_state_after_new_open.channelidentifiers_to_channels
assert len(ids_to_channels) == 2
assert channel_state.identifier in ids_to_channels
