def new_netting_channel(self, peer1, peer2, settle_timeout):
if not isaddress(peer1):
raise ValueError('The peer1 must be a valid address')
if not isaddress(peer2):
raise ValueError('The peer2 must be a valid address')
if settle_timeout < NETTINGCHANNEL_SETTLE_TIMEOUT_MIN:
raise ValueError(
'settle_timeout must be larger-or-equal to {}'.format(
NETTINGCHANNEL_SETTLE_TIMEOUT_MIN))
if peer1 == peer2:
raise SamePeerAddress('Peer1 and peer2 must not be equal')
if privatekey_to_address(self.client.privkey) == peer1:
other = peer2
else:
other = peer1
transaction_hash = estimate_and_transact(
self,
self.proxy.newChannel,
other,
settle_timeout,
)
self.client.poll(transaction_hash.decode('hex'),
timeout=self.poll_timeout)
if check_transaction_threw(self.client, transaction_hash):
raise DuplicatedChannelError('Duplicated channel')
netting_channel_results_encoded = self.proxy.getChannelWith.call(
other,
startgas=self.startgas,
)
# address is at index 0
netting_channel_address_encoded = netting_channel_results_encoded
if not netting_channel_address_encoded:
log.error('netting_channel_address failed',
peer1=pex(peer1),
peer2=pex(peer2))
raise RuntimeError('netting_channel_address failed')
netting_channel_address_bin = address_decoder(
netting_channel_address_encoded)
if log.isEnabledFor(logging.INFO):
log.info(
'new_netting_channel called',
peer1=pex(peer1),
peer2=pex(peer2),
netting_channel=pex(netting_channel_address_bin),
)
return netting_channel_address_bin
def new_netting_channel(self, other_peer, settle_timeout):
if not isaddress(other_peer):
raise ValueError('The other_peer must be a valid address')
invalid_timeout = (settle_timeout < NETTINGCHANNEL_SETTLE_TIMEOUT_MIN
or
settle_timeout > NETTINGCHANNEL_SETTLE_TIMEOUT_MAX)
if invalid_timeout:
raise ValueError('settle_timeout must be in range [{}, {}]'.format(
NETTINGCHANNEL_SETTLE_TIMEOUT_MIN,
NETTINGCHANNEL_SETTLE_TIMEOUT_MAX))
local_address = privatekey_to_address(self.client.privkey)
if local_address == other_peer:
raise SamePeerAddress(
'The other peer must not have the same address as the client.')
transaction_hash = estimate_and_transact(
self.proxy,
'newChannel',
self.startgas,
self.gasprice,
other_peer,
settle_timeout,
)
self.client.poll(unhexlify(transaction_hash),
timeout=self.poll_timeout)
if check_transaction_threw(self.client, transaction_hash):
raise DuplicatedChannelError('Duplicated channel')
netting_channel_results_encoded = self.proxy.call(
'getChannelWith',
other_peer,
startgas=self.startgas,
)
# address is at index 0
netting_channel_address_encoded = netting_channel_results_encoded
if not netting_channel_address_encoded:
log.error('netting_channel_address failed',
peer1=pex(local_address),
peer2=pex(other_peer))
raise RuntimeError('netting_channel_address failed')
netting_channel_address_bin = address_decoder(
netting_channel_address_encoded)
if log.isEnabledFor(logging.INFO):
log.info(
'new_netting_channel called',
peer1=pex(local_address),
peer2=pex(other_peer),
netting_channel=pex(netting_channel_address_bin),
)
return netting_channel_address_bin
def new_netting_channel(self, peer1, peer2, settle_timeout):
""" Creates a new netting contract between peer1 and peer2.
Raises:
ValueError: If peer1 or peer2 is not a valid address.
"""
if not isaddress(peer1):
raise ValueError('The peer1 must be a valid address')
if not isaddress(peer2):
raise ValueError('The peer2 must be a valid address')
if peer1 == peer2:
raise SamePeerAddress('peer1 and peer2 must not be equal')
invalid_timeout = (
settle_timeout < NETTINGCHANNEL_SETTLE_TIMEOUT_MIN or
settle_timeout > NETTINGCHANNEL_SETTLE_TIMEOUT_MAX
)
if invalid_timeout:
raise ValueError('settle_timeout must be in range [{}, {}]'.format(
NETTINGCHANNEL_SETTLE_TIMEOUT_MIN, NETTINGCHANNEL_SETTLE_TIMEOUT_MAX
))
if privatekey_to_address(self.private_key) == peer1:
other = peer2
else:
other = peer1
try:
netting_channel_address_hex = self.proxy.newChannel(other, settle_timeout)
except TransactionFailed:
raise DuplicatedChannelError('Duplicated channel')
self.tester_state.mine(number_of_blocks=1)
channel = NettingChannelTesterMock(
self.tester_state,
self.private_key,
netting_channel_address_hex,
)
return unhexlify(channel.address)
def new_netting_channel(self, other_peer, settle_timeout):
""" Creates a new netting contract between peer1 and peer2.
Raises:
ValueError: If other_peer is not a valid address.
"""
if not isaddress(other_peer):
raise ValueError('The other_peer must be a valid address')
local_address = privatekey_to_address(self.private_key)
if local_address == other_peer:
raise SamePeerAddress(
'The other peer must not have the same address as the client.')
invalid_timeout = (settle_timeout < NETTINGCHANNEL_SETTLE_TIMEOUT_MIN
or
settle_timeout > NETTINGCHANNEL_SETTLE_TIMEOUT_MAX)
if invalid_timeout:
raise ValueError('settle_timeout must be in range [{}, {}]'.format(
NETTINGCHANNEL_SETTLE_TIMEOUT_MIN,
NETTINGCHANNEL_SETTLE_TIMEOUT_MAX))
try:
netting_channel_address_hex = self.proxy.newChannel(
other_peer, settle_timeout, sender=self.private_key)
except TransactionFailed:
raise DuplicatedChannelError('Duplicated channel')
self.tester_chain.mine(number_of_blocks=1)
channel = NettingChannelTesterMock(
self.tester_chain,
self.private_key,
netting_channel_address_hex,
)
return address_decoder(channel.address)
def new_netting_channel(self, other_peer: Address,
settle_timeout: int) -> Address:
""" Creates and deploys a new netting channel contract.
Args:
other_peer: The peer to open the channel with.
settle_timeout: The settle timout to use for this channel.
Returns:
The address of the new netting channel.
"""
if not isaddress(other_peer):
raise ValueError('The other_peer must be a valid address')
invalid_timeout = (settle_timeout < NETTINGCHANNEL_SETTLE_TIMEOUT_MIN
or
settle_timeout > NETTINGCHANNEL_SETTLE_TIMEOUT_MAX)
if invalid_timeout:
raise InvalidSettleTimeout(
'settle_timeout must be in range [{}, {}]'.format(
NETTINGCHANNEL_SETTLE_TIMEOUT_MIN,
NETTINGCHANNEL_SETTLE_TIMEOUT_MAX))
local_address = privatekey_to_address(self.client.privkey)
if local_address == other_peer:
raise SamePeerAddress(
'The other peer must not have the same address as the client.')
transaction_hash = estimate_and_transact(
self.proxy,
'newChannel',
other_peer,
settle_timeout,
)
self.client.poll(unhexlify(transaction_hash),
timeout=self.poll_timeout)
if check_transaction_threw(self.client, transaction_hash):
raise DuplicatedChannelError('Duplicated channel')
netting_channel_results_encoded = self.proxy.call(
'getChannelWith',
other_peer,
)
# address is at index 0
netting_channel_address_encoded = netting_channel_results_encoded
if not netting_channel_address_encoded:
log.error('netting_channel_address failed',
peer1=pex(local_address),
peer2=pex(other_peer))
raise RuntimeError('netting_channel_address failed')
netting_channel_address_bin = address_decoder(
netting_channel_address_encoded)
if log.isEnabledFor(logging.INFO):
log.info(
'new_netting_channel called',
peer1=pex(local_address),
peer2=pex(other_peer),
netting_channel=pex(netting_channel_address_bin),
)
return netting_channel_address_bin
def new_netting_channel(
self,
partner: typing.Address,
settle_timeout: int,
) -> typing.ChannelID:
""" Creates a new channel in the TokenNetwork contract.
Args:
partner: The peer to open the channel with.
settle_timeout: The settle timout to use for this channel.
Returns:
The ChannelID of the new netting channel.
"""
if not is_binary_address(partner):
raise InvalidAddress(
'Expected binary address format for channel partner')
invalid_timeout = (settle_timeout < self.settlement_timeout_min()
or settle_timeout > self.settlement_timeout_max())
if invalid_timeout:
raise InvalidSettleTimeout(
'settle_timeout must be in range [{}, {}], is {}'.format(
self.settlement_timeout_min(),
self.settlement_timeout_max(),
settle_timeout,
))
if self.node_address == partner:
raise SamePeerAddress(
'The other peer must not have the same address as the client.')
log_details = {
'peer1': pex(self.node_address),
'peer2': pex(partner),
}
log.debug('new_netting_channel called', **log_details)
# Prevent concurrent attempts to open a channel with the same token and
# partner address.
if partner not in self.open_channel_transactions:
new_open_channel_transaction = AsyncResult()
self.open_channel_transactions[
partner] = new_open_channel_transaction
try:
transaction_hash = self._new_netting_channel(
partner, settle_timeout)
except Exception as e:
log.critical('new_netting_channel failed', **log_details)
new_open_channel_transaction.set_exception(e)
raise
else:
new_open_channel_transaction.set(transaction_hash)
finally:
self.open_channel_transactions.pop(partner, None)
else:
# All other concurrent threads should block on the result of opening this channel
self.open_channel_transactions[partner].get()
channel_created = self.channel_exists_and_not_settled(
self.node_address, partner)
if channel_created is False:
log.critical('new_netting_channel failed', **log_details)
raise RaidenUnrecoverableError('creating new channel failed')
channel_identifier = self.detail_channel(self.node_address,
partner).channel_identifier
log_details['channel_identifier'] = channel_identifier
log.info('new_netting_channel succesful', **log_details)
return channel_identifier
def new_netting_channel(self, other_peer: Address, settle_timeout: int) -> Address:
""" Creates and deploys a new netting channel contract.
Args:
other_peer: The peer to open the channel with.
settle_timeout: The settle timout to use for this channel.
Returns:
The address of the new netting channel.
"""
if not isaddress(other_peer):
raise ValueError('The other_peer must be a valid address')
invalid_timeout = (
settle_timeout < NETTINGCHANNEL_SETTLE_TIMEOUT_MIN or
settle_timeout > NETTINGCHANNEL_SETTLE_TIMEOUT_MAX
)
if invalid_timeout:
raise InvalidSettleTimeout('settle_timeout must be in range [{}, {}]'.format(
NETTINGCHANNEL_SETTLE_TIMEOUT_MIN, NETTINGCHANNEL_SETTLE_TIMEOUT_MAX
))
local_address = privatekey_to_address(self.client.privkey)
if local_address == other_peer:
raise SamePeerAddress('The other peer must not have the same address as the client.')
# Prevent concurrent attempts to open a channel with the same token and
# partner address.
if other_peer not in self.open_channel_transactions:
new_open_channel_transaction = AsyncResult()
self.open_channel_transactions[other_peer] = new_open_channel_transaction
try:
transaction_hash = self._new_netting_channel(other_peer, settle_timeout)
except Exception as e:
new_open_channel_transaction.set_exception(e)
raise
else:
new_open_channel_transaction.set(transaction_hash)
finally:
self.open_channel_transactions.pop(other_peer, None)
else:
# All other concurrent threads should block on the result of opening this channel
transaction_hash = self.open_channel_transactions[other_peer].get()
netting_channel_results_encoded = self.proxy.call(
'getChannelWith',
other_peer,
)
# address is at index 0
netting_channel_address_encoded = netting_channel_results_encoded
if not netting_channel_address_encoded:
log.error(
'netting_channel_address failed',
peer1=pex(local_address),
peer2=pex(other_peer)
)
raise RuntimeError('netting_channel_address failed')
netting_channel_address_bin = address_decoder(netting_channel_address_encoded)
log.info(
'new_netting_channel called',
peer1=pex(local_address),
peer2=pex(other_peer),
netting_channel=pex(netting_channel_address_bin),
)
return netting_channel_address_bin
def new_netting_channel(
self,
partner: typing.Address,
settle_timeout: int,
) -> typing.ChannelID:
""" Creates a new channel in the TokenNetwork contract.
Args:
partner: The peer to open the channel with.
settle_timeout: The settle timout to use for this channel.
Returns:
The address of the new netting channel.
"""
if not is_binary_address(partner):
raise InvalidAddress('Expected binary address format for channel partner')
invalid_timeout = (
settle_timeout < NETTINGCHANNEL_SETTLE_TIMEOUT_MIN or
settle_timeout > NETTINGCHANNEL_SETTLE_TIMEOUT_MAX
)
if invalid_timeout:
raise InvalidSettleTimeout('settle_timeout must be in range [{}, {}]'.format(
NETTINGCHANNEL_SETTLE_TIMEOUT_MIN, NETTINGCHANNEL_SETTLE_TIMEOUT_MAX,
))
if self.node_address == partner:
raise SamePeerAddress('The other peer must not have the same address as the client.')
# Prevent concurrent attempts to open a channel with the same token and
# partner address.
if partner not in self.open_channel_transactions:
new_open_channel_transaction = AsyncResult()
self.open_channel_transactions[partner] = new_open_channel_transaction
try:
transaction_hash = self._new_netting_channel(partner, settle_timeout)
except Exception as e:
new_open_channel_transaction.set_exception(e)
raise
else:
new_open_channel_transaction.set(transaction_hash)
finally:
self.open_channel_transactions.pop(partner, None)
else:
# All other concurrent threads should block on the result of opening this channel
transaction_hash = self.open_channel_transactions[partner].get()
channel_created = self.channel_exists(partner)
if channel_created is False:
log.error(
'creating new channel failed',
peer1=pex(self.node_address),
peer2=pex(partner),
)
raise RuntimeError('creating new channel failed')
channel_identifier = self.detail_channel(partner)['channel_identifier']
log.info(
'new_netting_channel called',
peer1=pex(self.node_address),
peer2=pex(partner),
channel_identifier=channel_identifier,
)
return channel_identifier
def transfer_async(
self,
registry_address: TokenNetworkRegistryAddress,
token_address: TokenAddress,
amount: PaymentAmount,
target: TargetAddress,
identifier: PaymentID = None,
secret: Secret = None,
secrethash: SecretHash = None,
lock_timeout: BlockTimeout = None,
) -> "PaymentStatus":
current_state = views.state_from_raiden(self.raiden)
token_network_registry_address = self.raiden.default_registry.address
if not isinstance(amount, int): # pragma: no unittest
raise InvalidAmount("Amount not a number")
if Address(target) == self.address:
raise SamePeerAddress("Address must be different than ours")
if amount <= 0:
raise InvalidAmount("Amount negative")
if amount > UINT256_MAX:
raise InvalidAmount("Amount too large")
if not is_binary_address(token_address):
raise InvalidBinaryAddress("token address is not valid.")
if token_address not in views.get_token_identifiers(
current_state, registry_address):
raise UnknownTokenAddress("Token address is not known.")
if not is_binary_address(target):
raise InvalidBinaryAddress("target address is not valid.")
valid_tokens = views.get_token_identifiers(
views.state_from_raiden(self.raiden), registry_address)
if token_address not in valid_tokens:
raise UnknownTokenAddress("Token address is not known.")
if secret is not None and not isinstance(secret, T_Secret):
raise InvalidSecret("secret is not valid.")
if secrethash is not None and not isinstance(secrethash, T_SecretHash):
raise InvalidSecretHash("secrethash is not valid.")
if identifier is None:
identifier = create_default_identifier()
if identifier <= 0:
raise InvalidPaymentIdentifier(
"Payment identifier cannot be 0 or negative")
if identifier > UINT64_MAX:
raise InvalidPaymentIdentifier("Payment identifier is too large")
log.debug(
"Initiating transfer",
initiator=to_checksum_address(self.raiden.address),
target=to_checksum_address(target),
token=to_checksum_address(token_address),
amount=amount,
identifier=identifier,
)
token_network_address = views.get_token_network_address_by_token_address(
chain_state=current_state,
token_network_registry_address=token_network_registry_address,
token_address=token_address,
)
if token_network_address is None:
raise UnknownTokenAddress(
f"Token {to_checksum_address(token_address)} is not registered "
f"with the network {to_checksum_address(registry_address)}.")
payment_status = self.raiden.mediated_transfer_async(
token_network_address=token_network_address,
amount=amount,
target=target,
identifier=identifier,
secret=secret,
secrethash=secrethash,
lock_timeout=lock_timeout,
)
return payment_status