def test_token(
deploy_client,
token_proxy,
private_keys,
blockchain_rpc_ports,
web3,
):
privkey = private_keys[1]
address = privatekey_to_address(privkey)
address = to_canonical_address(address)
other_client = JSONRPCClient(
'0.0.0.0',
blockchain_rpc_ports[0],
privkey,
web3=web3,
)
other_token_proxy = Token(
other_client,
to_canonical_address(token_proxy.proxy.contract.address),
)
# send some funds from deployer to generated address
transfer_funds = 100
token_proxy.transfer(address, transfer_funds)
assert transfer_funds == token_proxy.balance_of(address)
allow_funds = 100
token_proxy.approve(address, allow_funds)
assert allow_funds == token_proxy.proxy.contract.functions.allowance(
to_checksum_address(deploy_client.sender),
to_checksum_address(address),
).call()
other_token_proxy.transfer(deploy_client.sender, transfer_funds)
assert token_proxy.balance_of(address) == 0
def test_token(
deploy_client,
token_proxy,
private_keys,
web3,
contract_manager,
):
privkey = private_keys[1]
address = privatekey_to_address(privkey)
address = to_canonical_address(address)
other_client = JSONRPCClient(web3, privkey)
other_token_proxy = Token(
jsonrpc_client=other_client,
token_address=to_canonical_address(token_proxy.proxy.contract.address),
contract_manager=contract_manager,
)
# send some funds from deployer to generated address
transfer_funds = 100
token_proxy.transfer(address, transfer_funds, 'latest')
assert transfer_funds == token_proxy.balance_of(address)
allow_funds = 100
token_proxy.approve(address, allow_funds, 'latest')
assert allow_funds == token_proxy.proxy.contract.functions.allowance(
to_checksum_address(deploy_client.address),
to_checksum_address(address),
).call(block_identifier='latest')
other_token_proxy.transfer(deploy_client.address, transfer_funds, 'latest')
assert token_proxy.balance_of(address) == 0
def test_token(
deploy_client,
token_proxy,
private_keys,
web3,
contract_manager,
):
privkey = private_keys[1]
address = privatekey_to_address(privkey)
address = to_canonical_address(address)
other_client = JSONRPCClient(web3, privkey)
other_token_proxy = Token(
jsonrpc_client=other_client,
token_address=to_canonical_address(token_proxy.proxy.contract.address),
contract_manager=contract_manager,
)
# send some funds from deployer to generated address
transfer_funds = 100
token_proxy.transfer(address, transfer_funds)
assert transfer_funds == token_proxy.balance_of(address)
allow_funds = 100
token_proxy.approve(address, allow_funds)
assert allow_funds == token_proxy.proxy.contract.functions.allowance(
to_checksum_address(deploy_client.address),
to_checksum_address(address),
).call(block_identifier='latest')
other_token_proxy.transfer(deploy_client.address, transfer_funds)
assert token_proxy.balance_of(address) == 0
def token(self, token_address: Address) -> Token:
""" Return a proxy to interact with a token. """
if not is_binary_address(token_address):
raise ValueError('token_address must be a valid address')
if token_address not in self.address_to_token:
self.address_to_token[token_address] = Token(
self.client,
token_address,
)
return self.address_to_token[token_address]
def enough_balance_to_deposit(total_deposit: typing.TokenAmount,
address: typing.Address, token: Token,
log) -> EnoughBalance:
balance = token.balance_of(address)
if total_deposit is not None and total_deposit > balance:
error_msg = "Not enough balance to deposit. {} Available={} Needed={}".format(
pex(token.address), balance, total_deposit)
return EnoughBalance(
ApiErrorBuilder.build_and_log_error(
errors=error_msg,
status_code=HTTPStatus.PAYMENT_REQUIRED,
log=log), True, balance)
return EnoughBalance(None, True, balance)
def token(self, token_address: Address) -> Token:
""" Return a proxy to interact with a token. """
if not is_binary_address(token_address):
raise ValueError('token_address must be a valid address')
with self._token_creation_lock:
if token_address not in self.address_to_token:
self.address_to_token[token_address] = Token(
jsonrpc_client=self.client,
token_address=token_address,
contract_manager=self.contract_manager,
)
return self.address_to_token[token_address]
def token(self, token_address: bytes) -> Token:
""" Return a proxy to interact with a token. """
if not isaddress(token_address):
raise ValueError('token_address must be a valid address')
if token_address not in self.address_to_token:
self.address_to_token[token_address] = Token(
self.client,
token_address,
self.startgas,
self.gasprice,
self.poll_timeout,
)
return self.address_to_token[token_address]
def set_total_deposit(self, total_deposit: typing.TokenAmount, partner: typing.Address):
""" Set total token deposit in the channel to total_deposit.
Raises:
ChannelBusyError: If the channel is busy with another operation
RuntimeError: If the token address is empty.
"""
if not isinstance(total_deposit, int):
raise ValueError('total_deposit needs to be an integral number.')
token_address = self.token_address()
token = Token(self.client, token_address)
with self.channel_operations_lock[partner], self.deposit_lock:
# setTotalDeposit requires a monotonically increasing value. This
# is used to handle concurrent actions:
#
# - The deposits will be done in order, i.e. the monotonic
# property is preserved by the caller
# - The race of two deposits will be resolved with the larger
# deposit winning
# - Retries wont have effect
#
# This check is serialized with the channel_operations_lock to avoid
# sending invalid transactions on-chain (decreasing total deposit).
#
current_deposit = self.detail_participant(self.node_address, partner)['deposit']
amount_to_deposit = total_deposit - current_deposit
if amount_to_deposit <= 0:
raise ValueError(f'deposit {amount_to_deposit} must be greater than 0.')
# A node may be setting up multiple channels for the same token
# concurrently. Because each deposit changes the user balance this
# check must be serialized with the operation locks.
#
# This check is merely informational, used to avoid sending
# transactions which are known to fail.
#
# It is serialized with the deposit_lock to avoid sending invalid
# transactions on-chain (account without balance). The lock
# channel_operations_lock is not sufficient, as it allows two
# concurrent deposits for different channels.
#
current_balance = token.balance_of(self.node_address)
if current_balance < amount_to_deposit:
raise ValueError(
f'deposit {amount_to_deposit} can not be larger than the '
f'available balance {current_balance}, '
f'for token at address {pex(token_address)}',
)
# If there are channels being set up concurrenlty either the
# allowance must be accumulated *or* the calls to `approve` and
# `setTotalDeposit` must be serialized. This is necessary otherwise
# the deposit will fail.
#
# Calls to approve and setTotalDeposit are serialized with the
# deposit_lock to avoid transaction failure, because with two
# concurrent deposits, we may have the transactions executed in the
# following order
#
# - approve
# - approve
# - setTotalDeposit
# - setTotalDeposit
#
# in which case the second `approve` will overwrite the first,
# and the first `setTotalDeposit` will consume the allowance,
# making the second deposit fail.
token.approve(self.address, amount_to_deposit)
log_details = {
'token_network': pex(self.address),
'node': pex(self.node_address),
'partner': pex(partner),
'total_deposit': total_deposit,
'amount_to_deposit': amount_to_deposit,
'id': id(self),
}
log.info('deposit called', **log_details)
transaction_hash = self.proxy.transact(
'setTotalDeposit',
self.node_address,
total_deposit,
partner,
)
self.client.poll(unhexlify(transaction_hash))
receipt_or_none = check_transaction_threw(self.client, transaction_hash)
if receipt_or_none:
if token.allowance(self.node_address, self.address) < amount_to_deposit:
log_msg = (
'deposit failed. The allowance is insufficient, check concurrent deposits '
'for the same token network but different proxies.'
)
elif token.balance_of(self.node_address) < amount_to_deposit:
log_msg = 'deposit failed. The address doesnt have funds'
else:
log_msg = 'deposit failed'
log.critical(log_msg, **log_details)
channel_opened = self.channel_is_opened(self.node_address, partner)
if channel_opened is False:
raise ChannelIncorrectStateError(
'Channel is not in an opened state. A deposit cannot be made',
)
raise TransactionThrew('Deposit', receipt_or_none)
log.info('deposit successful', **log_details)
def set_total_deposit(
self,
channel_identifier: typing.ChannelID,
total_deposit: typing.TokenAmount,
partner: typing.Address,
):
""" Set total token deposit in the channel to total_deposit.
Raises:
ChannelBusyError: If the channel is busy with another operation
RuntimeError: If the token address is empty.
"""
if not isinstance(total_deposit, int):
raise ValueError('total_deposit needs to be an integral number.')
self._check_for_outdated_channel(
self.node_address,
partner,
channel_identifier,
)
token_address = self.token_address()
token = Token(self.client, token_address)
with self.channel_operations_lock[partner], self.deposit_lock:
# setTotalDeposit requires a monotonically increasing value. This
# is used to handle concurrent actions:
#
# - The deposits will be done in order, i.e. the monotonic
# property is preserved by the caller
# - The race of two deposits will be resolved with the larger
# deposit winning
# - Retries wont have effect
#
# This check is serialized with the channel_operations_lock to avoid
# sending invalid transactions on-chain (decreasing total deposit).
#
current_deposit = self.detail_participant(
channel_identifier,
self.node_address,
partner,
).deposit
amount_to_deposit = total_deposit - current_deposit
log_details = {
'token_network': pex(self.address),
'node': pex(self.node_address),
'partner': pex(partner),
'total_deposit': total_deposit,
'amount_to_deposit': amount_to_deposit,
'id': id(self),
}
log.debug('setTotalDeposit called', **log_details)
# These two scenarions can happen if two calls to deposit happen
# and then we get here on the second call
if total_deposit < current_deposit:
msg = (
f'Current deposit ({current_deposit}) is already larger '
f'than the requested total deposit amount ({total_deposit})'
)
log.info(f'setTotalDeposit failed, {msg}', **log_details)
raise DepositMismatch(msg)
if amount_to_deposit <= 0:
msg = (f'total_deposit - current_deposit = '
f'{amount_to_deposit} must be greater than 0.', )
log.info(f'setTotalDeposit failed, {msg}', **log_details)
raise DepositMismatch(msg)
# A node may be setting up multiple channels for the same token
# concurrently. Because each deposit changes the user balance this
# check must be serialized with the operation locks.
#
# This check is merely informational, used to avoid sending
# transactions which are known to fail.
#
# It is serialized with the deposit_lock to avoid sending invalid
# transactions on-chain (account without balance). The lock
# channel_operations_lock is not sufficient, as it allows two
# concurrent deposits for different channels.
#
current_balance = token.balance_of(self.node_address)
if current_balance < amount_to_deposit:
msg = (
f'total_deposit - current_deposit = {amount_to_deposit} can not '
f'be larger than the available balance {current_balance}, '
f'for token at address {pex(token_address)}')
log.info(f'setTotalDeposit failed, {msg}', **log_details)
raise DepositMismatch(msg)
# If there are channels being set up concurrenlty either the
# allowance must be accumulated *or* the calls to `approve` and
# `setTotalDeposit` must be serialized. This is necessary otherwise
# the deposit will fail.
#
# Calls to approve and setTotalDeposit are serialized with the
# deposit_lock to avoid transaction failure, because with two
# concurrent deposits, we may have the transactions executed in the
# following order
#
# - approve
# - approve
# - setTotalDeposit
# - setTotalDeposit
#
# in which case the second `approve` will overwrite the first,
# and the first `setTotalDeposit` will consume the allowance,
# making the second deposit fail.
token.approve(self.address, amount_to_deposit)
transaction_hash = self.proxy.transact(
'setTotalDeposit',
channel_identifier,
self.node_address,
total_deposit,
partner,
)
self.client.poll(transaction_hash)
receipt_or_none = check_transaction_threw(self.client,
transaction_hash)
if receipt_or_none:
if token.allowance(self.node_address,
self.address) < amount_to_deposit:
log_msg = (
'setTotalDeposit failed. The allowance is insufficient, '
'check concurrent deposits for the same token network '
'but different proxies.')
elif token.balance_of(self.node_address) < amount_to_deposit:
log_msg = 'setTotalDeposit failed. The address doesnt have funds'
else:
log_msg = 'setTotalDeposit failed'
log.critical(log_msg, **log_details)
self._check_channel_state_for_deposit(
self.node_address,
partner,
channel_identifier,
total_deposit,
)
raise TransactionThrew('Deposit', receipt_or_none)
log.info('setTotalDeposit successful', **log_details)
def test_blockchain(
init_blockchain,
web3,
blockchain_rpc_ports,
private_keys,
poll_timeout):
# pylint: disable=too-many-locals
addresses = [
privatekey_to_address(priv)
for priv in private_keys
]
privatekey = private_keys[0]
address = privatekey_to_address(privatekey)
total_token = 100
host = '127.0.0.1'
jsonrpc_client = JSONRPCClient(
host,
blockchain_rpc_ports[0],
privatekey,
web3=web3,
)
humantoken_path = get_contract_path('HumanStandardToken.sol')
humantoken_contracts = compile_files_cwd([humantoken_path])
token_proxy = jsonrpc_client.deploy_solidity_contract(
'HumanStandardToken',
humantoken_contracts,
list(),
(total_token, 'raiden', 2, 'Rd'),
contract_path=humantoken_path,
timeout=poll_timeout,
)
token_proxy = Token(jsonrpc_client, to_canonical_address(token_proxy.contract.address))
registry_path = get_contract_path('Registry.sol')
registry_contracts = compile_files_cwd([registry_path])
registry_proxy = jsonrpc_client.deploy_solidity_contract(
'Registry',
registry_contracts,
list(),
tuple(),
contract_path=registry_path,
timeout=poll_timeout,
)
registry_proxy = Registry(
jsonrpc_client,
to_canonical_address(registry_proxy.contract.address),
)
log_list = jsonrpc_client.web3.eth.getLogs(
{
'fromBlock': 0,
'toBlock': 'latest',
'topics': [],
},
)
assert not log_list
assert token_proxy.balance_of(address) == total_token
manager_address = registry_proxy.add_token(
to_canonical_address(token_proxy.proxy.contract.address),
)
assert is_address(manager_address)
assert len(registry_proxy.token_addresses()) == 1
log_list = jsonrpc_client.web3.eth.getLogs(
{
'fromBlock': 0,
'toBlock': 'latest',
'topics': [],
},
)
assert len(log_list) == 1
channel_manager_address_encoded = registry_proxy.manager_address_by_token(
token_proxy.proxy.contract.address,
)
channel_manager_address = to_canonical_address(channel_manager_address_encoded)
log = log_list[0]
event = decode_event(CONTRACT_MANAGER.get_contract_abi(CONTRACT_REGISTRY), log)
event_args = event['args']
assert channel_manager_address == to_canonical_address(event_args['channel_manager_address'])
assert is_same_address(token_proxy.proxy.contract.address, event_args['token_address'])
channel_manager_proxy = jsonrpc_client.new_contract_proxy(
CONTRACT_MANAGER.get_contract_abi(CONTRACT_CHANNEL_MANAGER),
channel_manager_address,
)
channel_manager_proxy = ChannelManager(
jsonrpc_client,
to_canonical_address(channel_manager_proxy.contract.address),
)
channel_address = channel_manager_proxy.new_netting_channel(
addresses[1],
10,
)
assert is_address(channel_address)
log_list = jsonrpc_client.web3.eth.getLogs(
{
'fromBlock': 0,
'toBlock': 'latest',
'topics': [],
},
)
assert len(log_list) == 2
def token_proxy(deploy_client, token_contract):
return Token(
deploy_client,
to_canonical_address(token_contract.contract.address),
)
def token_proxy(deploy_client, token_contract, contract_manager):
return Token(
jsonrpc_client=deploy_client,
token_address=to_canonical_address(token_contract.contract.address),
contract_manager=contract_manager,
)
def set_total_deposit(self, total_deposit: typing.TokenAmount,
partner: typing.Address):
""" Set total token deposit in the channel to total_deposit.
Raises:
ChannelBusyError: If the channel is busy with another operation
RuntimeError: If the token address is empty.
"""
if not isinstance(total_deposit, int):
raise ValueError('total_deposit needs to be an integral number.')
token_address = self.token_address()
token = Token(self.client, token_address)
self._check_channel_lock(partner)
with releasing(
self.channel_operations_lock[partner]), self.deposit_lock:
# setTotalDeposit requires a monotonically increasing value. This
# is used to handle concurrent actions:
#
# - The deposits will be done in order, i.e. the monotonic
# property is preserved by the caller
# - The race of two deposits will be resolved with the larger
# deposit winning
# - Retries wont have effect
#
# This check is serialized with the channel_operations_lock to avoid
# sending invalid transactions on-chain (decreasing total deposit).
#
current_deposit = self.detail_participant(self.node_address,
partner)['deposit']
amount_to_deposit = total_deposit - current_deposit
if amount_to_deposit <= 0:
raise ValueError(
f'deposit {amount_to_deposit} must be greater than 0.')
# A node may be setting up multiple channels for the same token
# concurrently. Because each deposit changes the user balance this
# check must be serialized with the operation locks.
#
# This check is merely informational, used to avoid sending
# transactions which are known to fail.
#
# It is serialized with the channel_operations_lock to avoid
# sending invalid transactions on-chain (account without balance).
#
current_balance = token.balance_of(self.node_address)
if current_balance < amount_to_deposit:
raise ValueError(
f'deposit {amount_to_deposit} can not be larger than the '
f'available balance {current_balance}, '
f'for token at address {pex(token_address)}', )
# If there are channels being set up concurrenlty either the
# allowance must be accumulated *or* the calls to `approve` and
# `setTotalDeposit` must be serialized. This is necessary otherwise
# the deposit will fail.
#
# Calls to approve and setTotalDeposit are serialized with the
# channel_operations_lock to avoid transaction failure, because
# with two concurrent deposits, we may have the transactions
# executed in the following order
#
# - approve
# - approve
# - setTotalDeposit
# - setTotalDeposit
#
# in which case the second `approve` will overwrite the first,
# and the first `setTotalDeposit` will consume the allowance,
# making the second deposit fail.
token.approve(self.address, amount_to_deposit)
log_details = {
'token_network': pex(self.address),
'node': pex(self.node_address),
'partner': pex(partner),
'total_deposit': total_deposit,
'amount_to_deposit': amount_to_deposit,
'id': id(self),
}
log.info('deposit called', **log_details)
transaction_hash = self.proxy.transact(
'setTotalDeposit',
self.node_address,
total_deposit,
partner,
)
self.client.poll(unhexlify(transaction_hash))
receipt_or_none = check_transaction_threw(self.client,
transaction_hash)
if receipt_or_none:
if token.allowance(self.node_address,
self.address) != amount_to_deposit:
log_msg = (
'Deposit failed and allowance was consumed. Check concurrent deposits '
'for the same token network but different proxies.')
else:
log_msg = 'deposit failed'
log.critical(log_msg, **log_details)
channel_opened = self.channel_is_opened(
self.node_address, partner)
if channel_opened is False:
raise ChannelIncorrectStateError(
'Channel is not in an opened state. A deposit cannot be made',
)
raise TransactionThrew('Deposit', receipt_or_none)
log.info('deposit successful', **log_details)
