def channel_open(
self,
registry_address,
token_address,
partner_address,
settle_timeout=None,
reveal_timeout=None,
poll_timeout=DEFAULT_POLL_TIMEOUT,
retry_timeout=DEFAULT_RETRY_TIMEOUT,
):
""" Open a channel with the peer at `partner_address`
with the given `token_address`.
"""
if reveal_timeout is None:
reveal_timeout = self.raiden.config['reveal_timeout']
if settle_timeout is None:
settle_timeout = self.raiden.config['settle_timeout']
if settle_timeout <= reveal_timeout:
raise InvalidSettleTimeout(
'reveal_timeout can not be larger-or-equal to settle_timeout',
)
if not is_binary_address(registry_address):
raise InvalidAddress(
'Expected binary address format for registry in channel open')
if not is_binary_address(token_address):
raise InvalidAddress(
'Expected binary address format for token in channel open')
if not is_binary_address(partner_address):
raise InvalidAddress(
'Expected binary address format for partner in channel open')
registry = self.raiden.chain.token_network_registry(registry_address)
token_network = registry.token_network_by_token(token_address)
channel_identifier = token_network.new_netting_channel(
partner_address,
settle_timeout,
)
msg = 'After {} seconds the channel was not properly created.'.format(
poll_timeout, )
with gevent.Timeout(poll_timeout, EthNodeCommunicationError(msg)):
waiting.wait_for_newchannel(
self.raiden,
registry_address,
token_address,
partner_address,
retry_timeout,
)
return channel_identifier
def channel_open(self,
token_address,
partner_address,
settle_timeout=None,
reveal_timeout=None,
poll_timeout=DEFAULT_POLL_TIMEOUT):
""" Open a channel with the peer at `partner_address`
with the given `token_address`.
"""
if reveal_timeout is None:
reveal_timeout = self.raiden.config['reveal_timeout']
if settle_timeout is None:
settle_timeout = self.raiden.config['settle_timeout']
if settle_timeout <= reveal_timeout:
raise InvalidSettleTimeout(
'reveal_timeout can not be larger-or-equal to settle_timeout')
if not isaddress(token_address):
raise InvalidAddress(
'Expected binary address format for token in channel open')
if not isaddress(partner_address):
raise InvalidAddress(
'Expected binary address format for partner in channel open')
channel_manager = self.raiden.default_registry.manager_by_token(
token_address)
netcontract_address = channel_manager.new_netting_channel(
partner_address,
settle_timeout,
)
msg = 'After {} seconds the channel was not properly created.'.format(
poll_timeout)
registry_address = self.raiden.default_registry.address
with gevent.Timeout(poll_timeout, EthNodeCommunicationError(msg)):
waiting.wait_for_newchannel(
self.raiden,
registry_address,
token_address,
partner_address,
self.raiden.alarm.wait_time,
)
return netcontract_address
def wait_for_usable_channel(
raiden: RaidenService,
partner_address: Address,
token_network_registry_address: TokenNetworkRegistryAddress,
token_address: TokenAddress,
our_deposit: TokenAmount,
partner_deposit: TokenAmount,
retry_timeout: float = DEFAULT_RETRY_TIMEOUT,
) -> None:
""" Wait until the channel from app0 to app1 is usable.
The channel and the deposits are registered, and the partner network state
is reachable.
"""
waiting.wait_for_newchannel(
raiden=raiden,
token_network_registry_address=token_network_registry_address,
token_address=token_address,
partner_address=partner_address,
retry_timeout=retry_timeout,
)
# wait for our deposit
waiting.wait_for_participant_deposit(
raiden=raiden,
token_network_registry_address=token_network_registry_address,
token_address=token_address,
partner_address=partner_address,
target_address=raiden.address,
target_balance=our_deposit,
retry_timeout=retry_timeout,
)
# wait for the partner deposit
waiting.wait_for_participant_deposit(
raiden=raiden,
token_network_registry_address=token_network_registry_address,
token_address=token_address,
partner_address=partner_address,
target_address=partner_address,
target_balance=partner_deposit,
retry_timeout=retry_timeout,
)
waiting.wait_for_healthy(raiden=raiden,
node_address=partner_address,
retry_timeout=retry_timeout)
def wait_for_usable_channel(
app0,
app1,
registry_address,
token_address,
our_deposit,
partner_deposit,
retry_timeout=DEFAULT_RETRY_TIMEOUT,
):
""" Wait until the channel from app0 to app1 is usable.
The channel and the deposits are registered, and the partner network state
is reachable.
"""
waiting.wait_for_newchannel(
app0.raiden,
registry_address,
token_address,
app1.raiden.address,
retry_timeout,
)
waiting.wait_for_participant_newbalance(
app0.raiden,
registry_address,
token_address,
app1.raiden.address,
app0.raiden.address,
our_deposit,
retry_timeout,
)
waiting.wait_for_participant_newbalance(
app0.raiden,
registry_address,
token_address,
app1.raiden.address,
app1.raiden.address,
partner_deposit,
retry_timeout,
)
waiting.wait_for_healthy(
app0.raiden,
app1.raiden.address,
retry_timeout,
)
def wait_for_usable_channel(
app0,
app1,
registry_address,
token_address,
our_deposit,
partner_deposit,
events_poll_timeout=0.5,
):
""" Wait until the channel from app0 to app1 is usable.
The channel and the deposits are registered, and the partner network state
is reachable.
"""
waiting.wait_for_newchannel(
app0.raiden,
registry_address,
token_address,
app1.raiden.address,
events_poll_timeout,
)
waiting.wait_for_participant_newbalance(
app0.raiden,
registry_address,
token_address,
app1.raiden.address,
app0.raiden.address,
our_deposit,
events_poll_timeout,
)
waiting.wait_for_participant_newbalance(
app0.raiden,
registry_address,
token_address,
app1.raiden.address,
app1.raiden.address,
partner_deposit,
events_poll_timeout,
)
waiting.wait_for_healthy(
app0.raiden,
app1.raiden.address,
events_poll_timeout,
)
def wait_both_channel_open(
app0,
app1,
registry_address,
token_address,
retry_timeout,
):
waiting.wait_for_newchannel(
app1.raiden,
registry_address,
token_address,
app0.raiden.address,
retry_timeout,
)
waiting.wait_for_newchannel(
app0.raiden,
registry_address,
token_address,
app1.raiden.address,
retry_timeout,
)
def wait_both_channel_open(
app0,
app1,
registry_address,
token_address,
retry_timeout,
):
waiting.wait_for_newchannel(
app1.raiden,
registry_address,
token_address,
app0.raiden.address,
retry_timeout,
)
waiting.wait_for_newchannel(
app0.raiden,
registry_address,
token_address,
app1.raiden.address,
retry_timeout,
)
def channel_open(
self,
registry_address: typing.PaymentNetworkID,
token_address: typing.TokenAddress,
partner_address: typing.Address,
settle_timeout: typing.BlockTimeout = None,
retry_timeout: typing.NetworkTimeout = DEFAULT_RETRY_TIMEOUT,
) -> typing.ChannelID:
""" Open a channel with the peer at `partner_address`
with the given `token_address`.
"""
if settle_timeout is None:
settle_timeout = self.raiden.config['settle_timeout']
if settle_timeout < self.raiden.config['reveal_timeout'] * 2:
raise InvalidSettleTimeout(
'settle_timeout can not be smaller than double the reveal_timeout',
)
if not is_binary_address(registry_address):
raise InvalidAddress('Expected binary address format for registry in channel open')
if not is_binary_address(token_address):
raise InvalidAddress('Expected binary address format for token in channel open')
if not is_binary_address(partner_address):
raise InvalidAddress('Expected binary address format for partner in channel open')
chain_state = views.state_from_raiden(self.raiden)
channel_state = views.get_channelstate_for(
chain_state=chain_state,
payment_network_id=registry_address,
token_address=token_address,
partner_address=partner_address,
)
if channel_state:
raise DuplicatedChannelError('Channel with given partner address already exists')
registry = self.raiden.chain.token_network_registry(registry_address)
token_network_address = registry.get_token_network(token_address)
if token_network_address is None:
raise TokenNotRegistered(
'Token network for token %s does not exist' % to_checksum_address(token_address),
)
token_network = self.raiden.chain.token_network(
registry.get_token_network(token_address),
)
with self.raiden.gas_reserve_lock:
has_enough_reserve, estimated_required_reserve = has_enough_gas_reserve(
self.raiden,
channels_to_open=1,
)
if not has_enough_reserve:
raise InsufficientGasReserve((
'The account balance is below the estimated amount necessary to '
'finish the lifecycles of all active channels. A balance of at '
f'least {estimated_required_reserve} wei is required.'
))
try:
token_network.new_netting_channel(
partner=partner_address,
settle_timeout=settle_timeout,
)
except DuplicatedChannelError:
log.info('partner opened channel first')
waiting.wait_for_newchannel(
raiden=self.raiden,
payment_network_id=registry_address,
token_address=token_address,
partner_address=partner_address,
retry_timeout=retry_timeout,
)
chain_state = views.state_from_raiden(self.raiden)
channel_state = views.get_channelstate_for(
chain_state=chain_state,
payment_network_id=registry_address,
token_address=token_address,
partner_address=partner_address,
)
return channel_state.identifier
def channel_open(
self,
registry_address,
token_address,
partner_address,
settle_timeout=None,
reveal_timeout=None,
poll_timeout=DEFAULT_POLL_TIMEOUT,
retry_timeout=DEFAULT_RETRY_TIMEOUT,
):
""" Open a channel with the peer at `partner_address`
with the given `token_address`.
"""
if reveal_timeout is None:
reveal_timeout = self.raiden.config['reveal_timeout']
if settle_timeout is None:
settle_timeout = self.raiden.config['settle_timeout']
if settle_timeout <= reveal_timeout:
raise InvalidSettleTimeout(
'reveal_timeout can not be larger-or-equal to settle_timeout',
)
if not is_binary_address(registry_address):
raise InvalidAddress(
'Expected binary address format for registry in channel open')
if not is_binary_address(token_address):
raise InvalidAddress(
'Expected binary address format for token in channel open')
if not is_binary_address(partner_address):
raise InvalidAddress(
'Expected binary address format for partner in channel open')
chain_state = views.state_from_raiden(self.raiden)
channel_state = views.get_channelstate_for(
chain_state,
registry_address,
token_address,
partner_address,
)
if channel_state:
raise DuplicatedChannelError(
'Channel with given partner address already exists')
registry = self.raiden.chain.token_network_registry(registry_address)
token_network = self.raiden.chain.token_network(
registry.get_token_network(token_address), )
try:
token_network.new_netting_channel(
partner_address,
settle_timeout,
)
except DuplicatedChannelError:
log.info('partner opened channel first')
msg = 'After {} seconds the channel was not properly created.'.format(
poll_timeout, )
with gevent.Timeout(poll_timeout, EthNodeCommunicationError(msg)):
waiting.wait_for_newchannel(
self.raiden,
registry_address,
token_address,
partner_address,
retry_timeout,
)
chain_state = views.state_from_raiden(self.raiden)
channel_state = views.get_channelstate_for(
chain_state,
registry_address,
token_address,
partner_address,
)
return channel_state.identifier
def channel_open(
self,
registry_address: PaymentNetworkID,
token_address: TokenAddress,
partner_address: Address,
settle_timeout: BlockTimeout = None,
retry_timeout: NetworkTimeout = DEFAULT_RETRY_TIMEOUT,
) -> ChannelID:
""" Open a channel with the peer at `partner_address`
with the given `token_address`.
"""
if settle_timeout is None:
settle_timeout = self.raiden.config["settle_timeout"]
if settle_timeout < self.raiden.config["reveal_timeout"] * 2:
raise InvalidSettleTimeout(
"settle_timeout can not be smaller than double the reveal_timeout"
)
if not is_binary_address(registry_address):
raise InvalidAddress("Expected binary address format for registry in channel open")
if not is_binary_address(token_address):
raise InvalidAddress("Expected binary address format for token in channel open")
if not is_binary_address(partner_address):
raise InvalidAddress("Expected binary address format for partner in channel open")
chain_state = views.state_from_raiden(self.raiden)
channel_state = views.get_channelstate_for(
chain_state=chain_state,
payment_network_id=registry_address,
token_address=token_address,
partner_address=partner_address,
)
if channel_state:
raise DuplicatedChannelError("Channel with given partner address already exists")
registry = self.raiden.chain.token_network_registry(registry_address)
token_network_address = registry.get_token_network(token_address)
if token_network_address is None:
raise TokenNotRegistered(
"Token network for token %s does not exist" % to_checksum_address(token_address)
)
token_network = self.raiden.chain.token_network(registry.get_token_network(token_address))
with self.raiden.gas_reserve_lock:
has_enough_reserve, estimated_required_reserve = has_enough_gas_reserve(
self.raiden, channels_to_open=1
)
if not has_enough_reserve:
raise InsufficientGasReserve(
(
"The account balance is below the estimated amount necessary to "
"finish the lifecycles of all active channels. A balance of at "
f"least {estimated_required_reserve} wei is required."
)
)
try:
token_network.new_netting_channel(
partner=partner_address,
settle_timeout=settle_timeout,
given_block_identifier=views.state_from_raiden(self.raiden).block_hash,
)
except DuplicatedChannelError:
log.info("partner opened channel first")
waiting.wait_for_newchannel(
raiden=self.raiden,
payment_network_id=registry_address,
token_address=token_address,
partner_address=partner_address,
retry_timeout=retry_timeout,
)
chain_state = views.state_from_raiden(self.raiden)
channel_state = views.get_channelstate_for(
chain_state=chain_state,
payment_network_id=registry_address,
token_address=token_address,
partner_address=partner_address,
)
assert channel_state, f"channel {channel_state} is gone"
return channel_state.identifier
def channel_open(
self,
registry_address: TokenNetworkRegistryAddress,
token_address: TokenAddress,
partner_address: Address,
settle_timeout: BlockTimeout = None,
reveal_timeout: BlockTimeout = None,
retry_timeout: NetworkTimeout = DEFAULT_RETRY_TIMEOUT,
) -> ChannelID:
""" Open a channel with the peer at `partner_address`
with the given `token_address`.
"""
if settle_timeout is None:
settle_timeout = self.raiden.config.settle_timeout
if reveal_timeout is None:
reveal_timeout = self.raiden.config.reveal_timeout
if reveal_timeout <= 0:
raise InvalidRevealTimeout(
"reveal_timeout should be larger than zero")
if settle_timeout < reveal_timeout * 2:
raise InvalidSettleTimeout(
"`settle_timeout` can not be smaller than double the "
"`reveal_timeout`.\n "
"\n "
"The setting `reveal_timeout` determines the maximum number of "
"blocks it should take a transaction to be mined when the "
"blockchain is under congestion. This setting determines the "
"when a node must go on-chain to register a secret, and it is "
"therefore the lower bound of the lock expiration. The "
"`settle_timeout` determines when a channel can be settled "
"on-chain, for this operation to be safe all locks must have "
"been resolved, for this reason the `settle_timeout` has to be "
"larger than `reveal_timeout`.")
if not is_binary_address(registry_address):
raise InvalidBinaryAddress(
"Expected binary address format for registry in channel open")
if not is_binary_address(token_address):
raise InvalidBinaryAddress(
"Expected binary address format for token in channel open")
if not is_binary_address(partner_address):
raise InvalidBinaryAddress(
"Expected binary address format for partner in channel open")
confirmed_block_identifier = views.get_confirmed_blockhash(self.raiden)
registry = self.raiden.proxy_manager.token_network_registry(
registry_address, block_identifier=confirmed_block_identifier)
settlement_timeout_min = registry.settlement_timeout_min(
block_identifier=confirmed_block_identifier)
settlement_timeout_max = registry.settlement_timeout_max(
block_identifier=confirmed_block_identifier)
if settle_timeout < settlement_timeout_min:
raise InvalidSettleTimeout(
f"Settlement timeout should be at least {settlement_timeout_min}"
)
if settle_timeout > settlement_timeout_max:
raise InvalidSettleTimeout(
f"Settlement timeout exceeds max of {settlement_timeout_max}")
token_network_address = registry.get_token_network(
token_address=token_address,
block_identifier=confirmed_block_identifier)
if token_network_address is None:
raise TokenNotRegistered(
"Token network for token %s does not exist" %
to_checksum_address(token_address))
token_network = self.raiden.proxy_manager.token_network(
address=token_network_address,
block_identifier=confirmed_block_identifier)
safety_deprecation_switch = token_network.safety_deprecation_switch(
block_identifier=confirmed_block_identifier)
if safety_deprecation_switch:
msg = (
"This token_network has been deprecated. New channels cannot be "
"open for this network, usage of the newly deployed token "
"network contract is highly encouraged.")
raise TokenNetworkDeprecated(msg)
duplicated_channel = self.is_already_existing_channel(
token_network_address=token_network_address,
partner_address=partner_address,
block_identifier=confirmed_block_identifier,
)
if duplicated_channel:
raise DuplicatedChannelError(
f"A channel with {to_checksum_address(partner_address)} for token "
f"{to_checksum_address(token_address)} already exists. "
f"(At blockhash: {confirmed_block_identifier.hex()})")
has_enough_reserve, estimated_required_reserve = has_enough_gas_reserve(
self.raiden, channels_to_open=1)
if not has_enough_reserve:
raise InsufficientGasReserve(
"The account balance is below the estimated amount necessary to "
"finish the lifecycles of all active channels. A balance of at "
f"least {estimated_required_reserve} wei is required.")
try:
token_network.new_netting_channel(
partner=partner_address,
settle_timeout=settle_timeout,
given_block_identifier=confirmed_block_identifier,
)
except DuplicatedChannelError:
log.info("partner opened channel first")
except RaidenRecoverableError:
# The channel may have been created in the pending block.
duplicated_channel = self.is_already_existing_channel(
token_network_address=token_network_address,
partner_address=partner_address)
if duplicated_channel:
log.info("Channel has already been opened")
else:
raise
waiting.wait_for_newchannel(
raiden=self.raiden,
token_network_registry_address=registry_address,
token_address=token_address,
partner_address=partner_address,
retry_timeout=retry_timeout,
)
chain_state = views.state_from_raiden(self.raiden)
channel_state = views.get_channelstate_for(
chain_state=chain_state,
token_network_registry_address=registry_address,
token_address=token_address,
partner_address=partner_address,
)
assert channel_state, f"channel {channel_state} is gone"
self.raiden.set_channel_reveal_timeout(
canonical_identifier=channel_state.canonical_identifier,
reveal_timeout=reveal_timeout)
return channel_state.identifier
def test_new_netting_contract(raiden_network, token_amount, settle_timeout):
# pylint: disable=line-too-long,too-many-statements,too-many-locals
app0, app1, app2 = raiden_network
peer0_address = app0.raiden.address
peer1_address = app1.raiden.address
peer2_address = app2.raiden.address
blockchain_service0 = app0.raiden.chain
registry = app0.raiden.default_registry
registry_address = app0.raiden.default_registry.address
humantoken_path = get_contract_path('HumanStandardToken.sol')
token_address = blockchain_service0.deploy_and_register_token(
registry,
contract_name='HumanStandardToken',
contract_path=humantoken_path,
constructor_parameters=(token_amount, 'raiden', 2, 'Rd'),
)
token0 = blockchain_service0.token(token_address)
for transfer_to in raiden_network[1:]:
token0.transfer(
privatekey_to_address(transfer_to.raiden.privkey),
token_amount // len(raiden_network),
)
manager0 = registry.manager_by_token(token_address)
# sanity
assert manager0.channels_addresses() == []
assert manager0.channels_by_participant(peer0_address) == []
assert manager0.channels_by_participant(peer1_address) == []
assert manager0.channels_by_participant(peer2_address) == []
# create one channel
netting_address_01 = manager0.new_netting_channel(
peer1_address,
settle_timeout,
)
exception = RuntimeError("Timeout while waiting for a new channel")
with gevent.Timeout(seconds=10, exception=exception):
waiting.wait_for_newchannel(
app1.raiden,
registry_address,
token_address,
app0.raiden.address,
app1.raiden.alarm.wait_time,
)
# check contract state
netting_channel_01 = blockchain_service0.netting_channel(netting_address_01)
assert netting_channel_01.can_transfer() is False
# check channels
channel_list = manager0.channels_addresses()
assert sorted(channel_list[0]) == sorted([peer0_address, peer1_address])
assert manager0.channels_by_participant(peer0_address) == [netting_address_01]
assert manager0.channels_by_participant(peer1_address) == [netting_address_01]
assert manager0.channels_by_participant(peer2_address) == []
# create a duplicated channel with same participants while previous channel
# is still open should throw an exception
with pytest.raises(Exception):
manager0.new_netting_channel(
peer1_address,
settle_timeout,
)
# create other channel
netting_address_02 = manager0.new_netting_channel(
peer2_address,
settle_timeout,
)
netting_channel_02 = blockchain_service0.netting_channel(netting_address_02)
assert netting_channel_02.can_transfer() is False
channel_list = manager0.channels_addresses()
expected_channels = [
sorted([peer0_address, peer1_address]),
sorted([peer0_address, peer2_address]),
]
for channel in channel_list:
assert sorted(channel) in expected_channels
result0 = sorted(manager0.channels_by_participant(peer0_address))
result1 = sorted([netting_address_01, netting_address_02])
assert result0 == result1
assert manager0.channels_by_participant(peer1_address) == [netting_address_01]
assert manager0.channels_by_participant(peer2_address) == [netting_address_02]
# deposit without approve should fail
netting_channel_01.set_total_deposit(100)
assert netting_channel_01.can_transfer() is False
assert netting_channel_02.can_transfer() is False
assert netting_channel_01.detail()['our_balance'] == 0
assert netting_channel_02.detail()['our_balance'] == 0
# single-funded channel
app0.raiden.chain.token(token_address).approve(netting_address_01, 100)
netting_channel_01.set_total_deposit(100)
assert netting_channel_01.can_transfer() is True
assert netting_channel_02.can_transfer() is False
assert netting_channel_01.detail()['our_balance'] == 100
assert netting_channel_02.detail()['our_balance'] == 0
# double-funded channel
app0.raiden.chain.token(token_address).approve(netting_address_02, 70)
netting_channel_02.set_total_deposit(70)
assert netting_channel_01.can_transfer() is True
assert netting_channel_02.can_transfer() is True
assert netting_channel_02.detail()['our_balance'] == 70
assert netting_channel_02.detail()['partner_balance'] == 0
app2.raiden.chain.token(token_address).approve(netting_address_02, 130)
app2.raiden.chain.netting_channel(netting_address_02).set_total_deposit(130)
assert netting_channel_01.can_transfer() is True
assert netting_channel_02.can_transfer() is True
assert netting_channel_02.detail()['our_balance'] == 70
assert netting_channel_02.detail()['partner_balance'] == 130
wait_until_block(app0.raiden.chain, app0.raiden.chain.block_number() + 2)
RaidenAPI(app1.raiden).channel_close(registry_address, token_address, app0.raiden.address)
waiting.wait_for_settle(
app1.raiden,
registry_address,
token_address,
[netting_address_01],
app1.raiden.alarm.wait_time,
)
with pytest.raises(AddressWithoutCode):
netting_channel_01.closed()
with pytest.raises(AddressWithoutCode):
netting_channel_01.opened()
# open channel with same peer again
netting_address_01_reopened = manager0.new_netting_channel(
peer1_address,
settle_timeout,
)
netting_channel_01_reopened = blockchain_service0.netting_channel(netting_address_01_reopened)
assert netting_channel_01_reopened.opened() != 0
assert netting_address_01_reopened in manager0.channels_by_participant(peer0_address)
assert netting_address_01 not in manager0.channels_by_participant(peer0_address)
app0.raiden.chain.token(token_address).approve(netting_address_01_reopened, 100)
netting_channel_01_reopened.set_total_deposit(100)
assert netting_channel_01_reopened.opened() != 0
def test_send_queued_messages(
raiden_network,
number_of_nodes,
deposit,
token_addresses,
network_wait,
skip_if_not_matrix,
):
"""Test re-sending of undelivered messages on node restart"""
app0, app1 = raiden_network
token_address = token_addresses[0]
chain_state = views.state_from_app(app0)
payment_network_id = app0.raiden.default_registry.address
token_network_identifier = views.get_token_network_identifier_by_token_address(
chain_state,
payment_network_id,
token_address,
)
with dont_handle_node_change_network_state():
# stop app1 - transfer must be left unconfirmed
app1.stop()
# make a few transfers from app0 to app1
amount = 1
spent_amount = 7
identifier = 1
for _ in range(spent_amount):
app0.raiden.mediated_transfer_async(
token_network_identifier=token_network_identifier,
amount=amount,
target=app1.raiden.address,
identifier=identifier,
)
identifier += 1
# restart app0
app0.raiden.stop()
new_transport = MatrixTransport(
app0.raiden.config['transport']['matrix'],
)
raiden_event_handler = RaidenEventHandler()
message_handler = MessageHandler()
app0_restart = App(
config=app0.config,
chain=app0.raiden.chain,
query_start_block=0,
default_registry=app0.raiden.default_registry,
default_secret_registry=app0.raiden.default_secret_registry,
transport=new_transport,
raiden_event_handler=raiden_event_handler,
message_handler=message_handler,
discovery=app0.raiden.discovery,
)
app0.stop()
del app0 # from here on the app0_restart should be used
app1.start()
app0_restart.start()
waiting.wait_for_healthy(
app0_restart.raiden,
app1.raiden.address,
network_wait,
)
waiting.wait_for_healthy(
app1.raiden,
app0_restart.raiden.address,
network_wait,
)
exception = RuntimeError('Timeout while waiting for new channel')
with gevent.Timeout(5, exception=exception):
waiting.wait_for_newchannel(
raiden=app0_restart.raiden,
payment_network_id=payment_network_id,
token_address=token_address,
partner_address=app1.raiden.address,
retry_timeout=network_wait,
)
exception = RuntimeError('Timeout while waiting for balance update for app0')
with gevent.Timeout(30, exception=exception):
waiting.wait_for_payment_balance(
raiden=app0_restart.raiden,
payment_network_id=payment_network_id,
token_address=token_address,
partner_address=app1.raiden.address,
target_address=app1.raiden.address,
target_balance=spent_amount,
retry_timeout=network_wait,
)
waiting.wait_for_payment_balance(
raiden=app1.raiden,
payment_network_id=payment_network_id,
token_address=token_address,
partner_address=app0_restart.raiden.address,
target_address=app1.raiden.address,
target_balance=spent_amount,
retry_timeout=network_wait,
)
assert_synced_channel_state(
token_network_identifier,
app0_restart, deposit - spent_amount, [],
app1, deposit + spent_amount, [],
)
def test_send_queued_messages(
raiden_network,
number_of_nodes,
deposit,
token_addresses,
network_wait,
skip_if_not_matrix,
):
"""Test re-sending of undelivered messages on node restart"""
app0, app1 = raiden_network
token_address = token_addresses[0]
chain_state = views.state_from_app(app0)
payment_network_id = app0.raiden.default_registry.address
token_network_identifier = views.get_token_network_identifier_by_token_address(
chain_state,
payment_network_id,
token_address,
)
# stop app1 - direct transfer must be left unconfirmed
app1.stop()
# make a few transfers from app0 to app2
amount = 1
spent_amount = 7
for _ in range(spent_amount):
direct_transfer(
app0,
app1,
token_network_identifier,
amount,
timeout=network_wait * number_of_nodes,
)
# restart app0
app0.raiden.stop()
new_transport = MatrixTransport(
app0.raiden.config['transport']['matrix'],
)
app0_restart = App(
config=app0.config,
chain=app0.raiden.chain,
query_start_block=0,
default_registry=app0.raiden.default_registry,
default_secret_registry=app0.raiden.default_secret_registry,
transport=new_transport,
discovery=app0.raiden.discovery,
)
app0.stop()
del app0 # from here on the app0_restart should be used
app1.start()
app0_restart.start()
waiting.wait_for_healthy(
app0_restart.raiden,
app1.raiden.address,
network_wait,
)
waiting.wait_for_healthy(
app1.raiden,
app0_restart.raiden.address,
network_wait,
)
exception = RuntimeError('Timeout while waiting for new channel')
with gevent.Timeout(5, exception=exception):
waiting.wait_for_newchannel(
app0_restart.raiden,
payment_network_id,
token_address,
app1.raiden.address,
network_wait,
)
exception = RuntimeError('Timeout while waiting for balance update for app0')
with gevent.Timeout(30, exception=exception):
waiting.wait_for_payment_balance(
app0_restart.raiden,
payment_network_id,
token_address,
app1.raiden.address,
app1.raiden.address,
spent_amount,
network_wait,
)
waiting.wait_for_payment_balance(
app1.raiden,
payment_network_id,
token_address,
app0_restart.raiden.address,
app1.raiden.address,
spent_amount,
network_wait,
)
assert_synced_channel_state(
token_network_identifier,
app0_restart, deposit - spent_amount, [],
app1, deposit + spent_amount, [],
)
def channel_open(
self,
registry_address: typing.PaymentNetworkID,
token_address: typing.TokenAddress,
partner_address: typing.Address,
settle_timeout: typing.BlockTimeout = None,
reveal_timeout: typing.BlockTimeout = None,
retry_timeout: typing.NetworkTimeout = DEFAULT_RETRY_TIMEOUT,
) -> typing.ChannelID:
""" Open a channel with the peer at `partner_address`
with the given `token_address`.
"""
if reveal_timeout is None:
reveal_timeout = self.raiden.config['reveal_timeout']
if settle_timeout is None:
settle_timeout = self.raiden.config['settle_timeout']
if settle_timeout <= reveal_timeout:
raise InvalidSettleTimeout(
'reveal_timeout can not be larger-or-equal to settle_timeout',
)
if not is_binary_address(registry_address):
raise InvalidAddress('Expected binary address format for registry in channel open')
if not is_binary_address(token_address):
raise InvalidAddress('Expected binary address format for token in channel open')
if not is_binary_address(partner_address):
raise InvalidAddress('Expected binary address format for partner in channel open')
chain_state = views.state_from_raiden(self.raiden)
channel_state = views.get_channelstate_for(
chain_state,
registry_address,
token_address,
partner_address,
)
if channel_state:
raise DuplicatedChannelError('Channel with given partner address already exists')
registry = self.raiden.chain.token_network_registry(registry_address)
token_network_address = registry.get_token_network(token_address)
if token_network_address is None:
raise TokenNotRegistered(
'Token network for token %s does not exist' % to_checksum_address(token_address),
)
token_network = self.raiden.chain.token_network(
registry.get_token_network(token_address),
)
try:
token_network.new_netting_channel(
partner_address,
settle_timeout,
)
except DuplicatedChannelError:
log.info('partner opened channel first')
waiting.wait_for_newchannel(
self.raiden,
registry_address,
token_address,
partner_address,
retry_timeout,
)
chain_state = views.state_from_raiden(self.raiden)
channel_state = views.get_channelstate_for(
chain_state,
registry_address,
token_address,
partner_address,
)
return channel_state.identifier
def channel_open(
self,
registry_address: typing.PaymentNetworkID,
token_address: typing.TokenAddress,
partner_address: typing.Address,
settle_timeout: typing.BlockTimeout = None,
retry_timeout: typing.NetworkTimeout = DEFAULT_RETRY_TIMEOUT,
) -> typing.ChannelID:
""" Open a channel with the peer at `partner_address`
with the given `token_address`.
"""
if settle_timeout is None:
settle_timeout = self.raiden.config['settle_timeout']
if settle_timeout < self.raiden.config['reveal_timeout'] * 2:
raise InvalidSettleTimeout(
'settle_timeout can not be smaller than double the reveal_timeout',
)
if not is_binary_address(registry_address):
raise InvalidAddress(
'Expected binary address format for registry in channel open')
if not is_binary_address(token_address):
raise InvalidAddress(
'Expected binary address format for token in channel open')
if not is_binary_address(partner_address):
raise InvalidAddress(
'Expected binary address format for partner in channel open')
chain_state = views.state_from_raiden(self.raiden)
channel_state = views.get_channelstate_for(
chain_state,
registry_address,
token_address,
partner_address,
)
if channel_state:
raise DuplicatedChannelError(
'Channel with given partner address already exists')
registry = self.raiden.chain.token_network_registry(registry_address)
token_network_address = registry.get_token_network(token_address)
if token_network_address is None:
raise TokenNotRegistered(
'Token network for token %s does not exist' %
to_checksum_address(token_address), )
token_network = self.raiden.chain.token_network(
registry.get_token_network(token_address), )
has_enough_reserve, estimated_required_reserve = has_enough_gas_reserve(
self.raiden,
channels_to_open=1,
)
if not has_enough_reserve:
raise InsufficientGasReserve((
'The account balance is below the estimated amount necessary to '
'finish the lifecycles of all active channels. A balance of at '
f'least {estimated_required_reserve} wei is required.'))
try:
token_network.new_netting_channel(
partner_address,
settle_timeout,
)
except DuplicatedChannelError:
log.info('partner opened channel first')
waiting.wait_for_newchannel(
self.raiden,
registry_address,
token_address,
partner_address,
retry_timeout,
)
chain_state = views.state_from_raiden(self.raiden)
channel_state = views.get_channelstate_for(
chain_state,
registry_address,
token_address,
partner_address,
)
return channel_state.identifier
def payment_channel_open_and_deposit(
app0: App,
app1: App,
token_address: TokenAddress,
deposit: TokenAmount,
settle_timeout: BlockTimeout,
) -> None:
""" Open a new channel with app0 and app1 as participants """
assert token_address
block_identifier: BlockIdentifier
if app0.raiden.wal:
block_identifier = views.get_confirmed_blockhash(app0.raiden)
else:
block_identifier = BLOCK_ID_LATEST
token_network_address = app0.raiden.default_registry.get_token_network(
token_address=token_address, block_identifier=block_identifier)
assert token_network_address, "request a channel for an unregistered token"
token_network_proxy = app0.raiden.proxy_manager.token_network(
token_network_address, block_identifier=BLOCK_ID_LATEST)
channel_identifier, _, _ = token_network_proxy.new_netting_channel(
partner=app1.raiden.address,
settle_timeout=settle_timeout,
given_block_identifier=block_identifier,
)
assert channel_identifier
if deposit != 0:
for app, partner in [(app0, app1), (app1, app0)]:
waiting.wait_for_newchannel(
raiden=app.raiden,
token_network_registry_address=app.raiden.default_registry.
address,
token_address=token_address,
partner_address=partner.raiden.address,
retry_timeout=0.5,
)
chain_state = state_from_raiden(app.raiden)
canonical_identifier = CanonicalIdentifier(
chain_identifier=chain_state.chain_id,
token_network_address=token_network_proxy.address,
channel_identifier=channel_identifier,
)
channel_state = get_channelstate_by_canonical_identifier(
chain_state=chain_state,
canonical_identifier=canonical_identifier)
assert channel_state, "nodes dont share a channel"
# Use each app's own chain because of the private key / local signing
token = app.raiden.proxy_manager.token(token_address,
BLOCK_ID_LATEST)
payment_channel_proxy = app.raiden.proxy_manager.payment_channel(
channel_state=channel_state, block_identifier=BLOCK_ID_LATEST)
# This check can succeed and the deposit still fail, if channels are
# openned in parallel
previous_balance = token.balance_of(app.raiden.address)
assert previous_balance >= deposit
# the payment channel proxy will call approve
# token.approve(token_network_proxy.address, deposit)
payment_channel_proxy.approve_and_set_total_deposit(
total_deposit=deposit, block_identifier=BLOCK_ID_LATEST)
# Balance must decrease by at least but not exactly `deposit` amount,
# because channels can be openned in parallel
new_balance = token.balance_of(app.raiden.address)
assert new_balance <= previous_balance - deposit
check_channel(app0, app1, token_network_proxy.address, settle_timeout,
deposit)
def run_test_send_queued_messages(
raiden_network,
deposit,
token_addresses,
network_wait,
):
app0, app1 = raiden_network
token_address = token_addresses[0]
chain_state = views.state_from_app(app0)
payment_network_id = app0.raiden.default_registry.address
token_network_identifier = views.get_token_network_identifier_by_token_address(
chain_state,
payment_network_id,
token_address,
)
with dont_handle_node_change_network_state():
# stop app1 - transfer must be left unconfirmed
app1.stop()
# make a few transfers from app0 to app1
amount = 1
spent_amount = 7
identifier = 1
for _ in range(spent_amount):
app0.raiden.mediated_transfer_async(
token_network_identifier=token_network_identifier,
amount=amount,
target=app1.raiden.address,
identifier=identifier,
)
identifier += 1
# restart app0
app0.raiden.stop()
new_transport = MatrixTransport(
app0.raiden.config['transport']['matrix'], )
raiden_event_handler = RaidenEventHandler()
message_handler = MessageHandler()
app0_restart = App(
config=app0.config,
chain=app0.raiden.chain,
query_start_block=0,
default_registry=app0.raiden.default_registry,
default_secret_registry=app0.raiden.default_secret_registry,
default_service_registry=app0.raiden.default_service_registry,
transport=new_transport,
raiden_event_handler=raiden_event_handler,
message_handler=message_handler,
discovery=app0.raiden.discovery,
)
app0.stop()
del app0 # from here on the app0_restart should be used
app1.start()
app0_restart.start()
waiting.wait_for_healthy(
app0_restart.raiden,
app1.raiden.address,
network_wait,
)
waiting.wait_for_healthy(
app1.raiden,
app0_restart.raiden.address,
network_wait,
)
exception = RuntimeError('Timeout while waiting for new channel')
with gevent.Timeout(5, exception=exception):
waiting.wait_for_newchannel(
raiden=app0_restart.raiden,
payment_network_id=payment_network_id,
token_address=token_address,
partner_address=app1.raiden.address,
retry_timeout=network_wait,
)
exception = RuntimeError(
'Timeout while waiting for balance update for app0')
with gevent.Timeout(30, exception=exception):
waiting.wait_for_payment_balance(
raiden=app0_restart.raiden,
payment_network_id=payment_network_id,
token_address=token_address,
partner_address=app1.raiden.address,
target_address=app1.raiden.address,
target_balance=spent_amount,
retry_timeout=network_wait,
)
waiting.wait_for_payment_balance(
raiden=app1.raiden,
payment_network_id=payment_network_id,
token_address=token_address,
partner_address=app0_restart.raiden.address,
target_address=app1.raiden.address,
target_balance=spent_amount,
retry_timeout=network_wait,
)
assert_synced_channel_state(
token_network_identifier,
app0_restart,
deposit - spent_amount,
[],
app1,
deposit + spent_amount,
[],
)
def channel_open(
self,
registry_address,
token_address,
partner_address,
settle_timeout=None,
reveal_timeout=None,
poll_timeout=DEFAULT_POLL_TIMEOUT,
retry_timeout=DEFAULT_RETRY_TIMEOUT,
):
""" Open a channel with the peer at `partner_address`
with the given `token_address`.
"""
if reveal_timeout is None:
reveal_timeout = self.raiden.config['reveal_timeout']
if settle_timeout is None:
settle_timeout = self.raiden.config['settle_timeout']
if settle_timeout <= reveal_timeout:
raise InvalidSettleTimeout(
'reveal_timeout can not be larger-or-equal to settle_timeout',
)
if not is_binary_address(registry_address):
raise InvalidAddress('Expected binary address format for registry in channel open')
if not is_binary_address(token_address):
raise InvalidAddress('Expected binary address format for token in channel open')
if not is_binary_address(partner_address):
raise InvalidAddress('Expected binary address format for partner in channel open')
chain_state = views.state_from_raiden(self.raiden)
channel_state = views.get_channelstate_for(
chain_state,
registry_address,
token_address,
partner_address,
)
if channel_state:
raise DuplicatedChannelError('Channel with given partner address already exists')
registry = self.raiden.chain.token_network_registry(registry_address)
token_network = self.raiden.chain.token_network(
registry.get_token_network(token_address),
)
try:
token_network.new_netting_channel(
partner_address,
settle_timeout,
)
except DuplicatedChannelError:
log.info('partner opened channel first')
msg = 'After {} seconds the channel was not properly created.'.format(
poll_timeout,
)
with gevent.Timeout(poll_timeout, EthNodeCommunicationError(msg)):
waiting.wait_for_newchannel(
self.raiden,
registry_address,
token_address,
partner_address,
retry_timeout,
)
chain_state = views.state_from_raiden(self.raiden)
channel_state = views.get_channelstate_for(
chain_state,
registry_address,
token_address,
partner_address,
)
return channel_state.identifier
