def event_channelnew(self, manager_address_bin, event): # pylint: disable=unused-argument
# should not raise, filters are installed only for registered managers
asset_manager = self.raiden.get_manager_by_address(manager_address_bin)
participant1 = address_decoder(event['participant1'])
participant2 = address_decoder(event['participant2'])
# update our global network graph for routing
asset_manager.channelgraph.add_path(
participant1,
participant2,
)
if participant1 == self.raiden.address or participant2 == self.raiden.address:
netting_channel_address_bin = address_decoder(event['netting_channel'])
try:
asset_manager.register_channel_by_address(
netting_channel_address_bin,
self.raiden.config['reveal_timeout'],
)
except ValueError:
# This can happen if the new channel's settle_timeout is
# smaller than raiden.config['reveal_timeout']
log.exception('Channel registration failed.')
else:
if log.isEnabledFor(logging.INFO):
log.info(
'New channel created',
channel_address=event['netting_channel'],
manager_address=pex(manager_address_bin),
)
else:
log.info('ignoring new channel, this is node is not a participant.')
def partner(self, our_address):
data = self.proxy.addressAndBalance.call()
if address_decoder(data[0]) == our_address:
return address_decoder(data[2])
if address_decoder(data[2]) == our_address:
return address_decoder(data[0])
raise ValueError('We [{}] are not a participant of the given channel ({}, {})'.format(
pex(our_address),
data[0],
data[2],
))
def event_channelnewbalance(self, netting_contract_address_bin, event):
asset_address_bin = address_decoder(event['assetAddress'])
participant_address_bin = address_decoder(event['participant'])
# shouldn't raise, all three addresses need to be registered
manager = self.raiden.get_manager_by_asset_address(asset_address_bin)
channel = manager.get_channel_by_contract_address(netting_contract_address_bin)
channel_state = channel.get_state_for(participant_address_bin)
if channel_state.contract_balance != event['balance']:
channel_state.update_contract_balance(event['balance'])
if channel.external_state.opened_block == 0:
channel.external_state.opened_block = event['blockNumber']
def changes(self):
filter_changes = self.client.call(
'eth_getFilterChanges',
self.filter_id_raw,
)
# geth could return None
if filter_changes is None:
return []
result = list()
for log_event in filter_changes:
address = address_decoder(log_event['address'])
data = data_decoder(log_event['data'])
topics = [
decode_topic(topic)
for topic in log_event['topics']
]
result.append({
'topics': topics,
'data': data,
'address': address,
})
return result
def channels_by_participant(self, peer_address):
result = [
address_decoder(address)
for address in self.proxy.nettingContractsByAddress(peer_address)
]
self.tester_state.mine(number_of_blocks=1)
return result
def closing_address(self):
"""Returns the address of the participant that called close, or None if the channel is
not closed.
"""
self._check_exists()
closing_address = self.proxy.closingAddress()
if closing_address is not None:
return address_decoder(closing_address)
def channels_by_participant(self, participant_address): # pylint: disable=invalid-name
""" Return a list of channel address that `participant_address` is a participant. """
address_list = self.proxy.nettingContractsByAddress.call(
participant_address,
startgas=self.startgas,
)
return [address_decoder(address) for address in address_list]
def get_channel(self, channel_address):
channel_address_bin = address_decoder(channel_address)
channel_list = self.get_channel_list()
for channel in channel_list:
if channel.channel_address == channel_address_bin:
return channel
raise ValueError("Channel not found")
def api_url_for(api_backend, endpoint, **kwargs):
api_server, _ = api_backend
# url_for() expects binary address so we have to convert here
for key, val in kwargs.iteritems():
if isinstance(val, basestring) and val.startswith('0x'):
kwargs[key] = address_decoder(val)
with api_server.flask_app.app_context():
return url_for('v1_resources.{}'.format(endpoint), **kwargs)
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)
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 event_channelclosed(self, netting_contract_address_bin, event):
channel = self.raiden.find_channel_by_address(
netting_contract_address_bin)
channel.external_state.set_closed(event['block_number'])
callback = self.get_on_event_callback(event)
if callback:
closing_address_bin = address_decoder(event['closing_address'])
callback(netting_contract_address_bin, closing_address_bin,
event['block_number'])
def event_channelnew(self, manager_address_bin, event): # pylint: disable=unused-argument
if address_decoder(event['participant1']) != self.raiden.address and address_decoder(event['participant2']) != self.raiden.address:
log.info('ignoring new channel, this is node is not a participant.')
return
netting_channel_address_bin = address_decoder(event['nettingChannel'])
# shouldnt raise, filters are installed only for registered managers
asset_manager = self.raiden.get_manager_by_address(manager_address_bin)
asset_manager.register_channel_by_address(
netting_channel_address_bin,
self.raiden.config['reveal_timeout'],
)
log.info(
'New channel created',
channel_address=event['nettingChannel'],
manager_address=pex(manager_address_bin),
)
def event_channelnew(self, manager_address, event): # pylint: disable=unused-argument
if address_decoder(event['participant1']) != self.raiden.address and address_decoder(event['participant2']) != self.raiden.address:
log.info('ignoring new channel, this is node is not a participant.')
return
netting_channel_address_bin = address_decoder(event['nettingChannel'])
# shouldnt raise, filters are installed only for registered managers
asset_manager = self.raiden.get_manager_by_address(manager_address)
asset_manager.register_channel_by_address(
netting_channel_address_bin,
self.raiden.config['reveal_timeout'],
)
log.info(
'New channel created',
channel_address=event['nettingChannel'],
manager_address=encode_hex(manager_address),
)
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 privatekey_to_address(self.client.privkey) == peer1:
other = peer2
else:
other = peer1
transaction_hash = estimate_and_transact(
self,
self.proxy.newChannel,
other,
settle_timeout,
)
try:
self.client.poll(transaction_hash.decode('hex'),
timeout=self.poll_timeout)
except JSONRPCPollTimeoutException as e:
raise e
except InvalidTransaction as e:
raise e
# TODO: raise if the transaction failed because there is an existing
# channel in place
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)
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 channels_by_participant(self, participant_address): # pylint: disable=invalid-name
""" Return a list of channel address that `participant_address` is a participant. """
address_list = self.proxy.nettingContractsByAddress.call(
participant_address,
startgas=self.startgas,
)
return [
address_decoder(address)
for address in address_list
]
def event_channelnew(self, manager_address_bin, event): # pylint: disable=unused-argument
# should not raise, filters are installed only for registered managers
token_manager = self.raiden.get_manager_by_address(manager_address_bin)
participant1 = address_decoder(event['participant1'])
participant2 = address_decoder(event['participant2'])
# update our global network graph for routing
token_manager.channelgraph.add_path(
participant1,
participant2,
)
if participant1 == self.raiden.address or participant2 == self.raiden.address:
netting_channel_address_bin = address_decoder(
event['netting_channel'])
try:
token_manager.register_channel_by_address(
netting_channel_address_bin,
self.raiden.config['reveal_timeout'],
)
except ValueError:
# This can happen if the new channel's settle_timeout is
# smaller than raiden.config['reveal_timeout']
log.exception('Channel registration failed.')
else:
if log.isEnabledFor(logging.INFO):
log.info(
'New channel created',
channel_address=event['netting_channel'],
manager_address=pex(manager_address_bin),
)
callback = self.get_on_event_callback(event)
if callback:
callback(netting_channel_address_bin, participant1,
participant2, event['settle_timeout'])
else:
log.info('ignoring new channel, this node is not a participant.')
def event_channelnewbalance(self, netting_contract_address_bin, event):
if log.isEnabledFor(logging.DEBUG):
log.debug(
'channel new balance event received',
netting_contract=pex(netting_contract_address_bin),
event=event,
)
asset_address_bin = address_decoder(event['asset_address'])
participant_address_bin = address_decoder(event['participant'])
# should not raise, all three addresses need to be registered
manager = self.raiden.get_manager_by_asset_address(asset_address_bin)
channel = manager.get_channel_by_contract_address(netting_contract_address_bin)
channel_state = channel.get_state_for(participant_address_bin)
if channel_state.contract_balance != event['balance']:
channel_state.update_contract_balance(event['balance'])
if channel.external_state.opened_block == 0:
channel.external_state.set_opened(event['block_number'])
def detail(self, our_address):
""" FIXME: 'our_address' is only needed for the pure python mock implementation """
our_address = privatekey_to_address(self.private_key)
data = self.proxy.addressAndBalance()
self.tester_state.mine(number_of_blocks=1)
settle_timeout = self.proxy.settleTimeout()
self.tester_state.mine(number_of_blocks=1)
if address_decoder(data[0]) == our_address:
return {
'our_address': address_decoder(data[0]),
'our_balance': data[1],
'partner_address': address_decoder(data[2]),
'partner_balance': data[3],
'settle_timeout': settle_timeout,
}
if address_decoder(data[2]) == our_address:
return {
'our_address': address_decoder(data[2]),
'our_balance': data[3],
'partner_address': address_decoder(data[0]),
'partner_balance': data[1],
'settle_timeout': settle_timeout,
}
raise ValueError(
'We [{}] are not a participant of the given channel ({}, {})'.
format(
pex(our_address),
data[0],
data[2],
))
def detail(self, our_address):
data = self.proxy.addressAndBalance()
self.tester_state.mine(number_of_blocks=1)
settle_timeout = self.proxy.settleTimeout()
self.tester_state.mine(number_of_blocks=1)
if address_decoder(data[0]) == our_address:
return {
'our_address': address_decoder(data[0]),
'our_balance': data[1],
'partner_address': address_decoder(data[2]),
'partner_balance': data[3],
'settle_timeout': settle_timeout,
}
if address_decoder(data[2]) == our_address:
return {
'our_address': address_decoder(data[2]),
'our_balance': data[3],
'partner_address': address_decoder(data[0]),
'partner_balance': data[1],
'settle_timeout': settle_timeout,
}
raise ValueError('We [{}] are not a participant of the given channel ({}, {})'.format(
pex(our_address),
data[0],
data[2],
))
def detail(self, our_address):
data = self.proxy.addressAndBalance.call(startgas=self.startgas)
settle_timeout = self.proxy.settleTimeout.call(startgas=self.startgas)
if address_decoder(data[0]) == our_address:
return {
'our_address': address_decoder(data[0]),
'our_balance': data[1],
'partner_address': address_decoder(data[2]),
'partner_balance': data[3],
'settle_timeout': settle_timeout,
}
if address_decoder(data[2]) == our_address:
return {
'our_address': address_decoder(data[2]),
'our_balance': data[3],
'partner_address': address_decoder(data[0]),
'partner_balance': data[1],
'settle_timeout': settle_timeout,
}
raise ValueError(
'We [{}] are not a participant of the given channel ({}, {})'.
format(
pex(our_address),
data[0],
data[2],
))
def detail(self, our_address):
data = self.proxy.addressAndBalance.call(startgas=self.startgas)
settle_timeout = self.proxy.settleTimeout.call(startgas=self.startgas)
if data == '':
raise RuntimeError('addressAndBalance call failed.')
if settle_timeout == '':
raise RuntimeError('settleTimeout call failed.')
if address_decoder(data[0]) == our_address:
return {
'our_address': address_decoder(data[0]),
'our_balance': data[1],
'partner_address': address_decoder(data[2]),
'partner_balance': data[3],
'settle_timeout': settle_timeout,
}
if address_decoder(data[2]) == our_address:
return {
'our_address': address_decoder(data[2]),
'our_balance': data[3],
'partner_address': address_decoder(data[0]),
'partner_balance': data[1],
'settle_timeout': settle_timeout,
}
raise ValueError('We [{}] are not a participant of the given channel ({}, {})'.format(
pex(our_address),
data[0],
data[2],
))
def detail(self, our_address):
data = self.proxy.addressAndBalance()
self.tester_state.mine(number_of_blocks=1)
settle_timeout = self.proxy.settleTimeout()
self.tester_state.mine(number_of_blocks=1)
if address_decoder(data[0]) == our_address:
return {
'our_address': address_decoder(data[0]),
'our_balance': data[1],
'partner_address': address_decoder(data[2]),
'partner_balance': data[3],
'settle_timeout': settle_timeout,
}
if address_decoder(data[2]) == our_address:
return {
'our_address': address_decoder(data[2]),
'our_balance': data[3],
'partner_address': address_decoder(data[0]),
'partner_balance': data[1],
'settle_timeout': settle_timeout,
}
raise ValueError('We [{}] are not a participant of the given channel ({}, {})'.format(
pex(our_address),
data[0],
data[2],
))
def channels_addresses(self):
# for simplicity the smart contract return a shallow list where every
# second item forms a tuple
channel_flat_encoded = self.proxy.getChannelsParticipants.call(startgas=self.startgas)
channel_flat = [
address_decoder(channel)
for channel in channel_flat_encoded
]
# [a,b,c,d] -> [(a,b),(c,d)]
channel_iter = iter(channel_flat)
return zip(channel_iter, channel_iter)
def channels_addresses(self):
# for simplicity the smart contract return a shallow list where every
# second item forms a tuple
channel_flat_encoded = self.proxy.getChannelsParticipants.call(
startgas=self.startgas)
channel_flat = [
address_decoder(channel) for channel in channel_flat_encoded
]
# [a,b,c,d] -> [(a,b),(c,d)]
channel_iter = iter(channel_flat)
return zip(channel_iter, channel_iter)
def closing_address(self):
""" Returns the address of the closer, if the channel is closed, None
otherwise.
Raises:
AddressWithoutCode: If the channel was settled prior to the call.
"""
closer = self.proxy.closingAddress()
if closer:
return address_decoder(closer)
return None
def token_address(self):
""" Returns the type of token that can be transferred by the channel.
Raises:
AddressWithoutCode: If the channel was settled prior to the call.
"""
address = self.proxy.tokenAddress.call()
if address == '':
self._check_exists()
raise RuntimeError('token address returned empty')
return address_decoder(address)
def event_channelnewbalance(self, netting_contract_address_bin, event):
if log.isEnabledFor(logging.DEBUG):
log.debug(
'channel new balance event received',
netting_contract=pex(netting_contract_address_bin),
event=event,
)
asset_address_bin = address_decoder(event['asset_address'])
participant_address_bin = address_decoder(event['participant'])
# should not raise, all three addresses need to be registered
manager = self.raiden.get_manager_by_asset_address(asset_address_bin)
channel = manager.get_channel_by_contract_address(
netting_contract_address_bin)
channel_state = channel.get_state_for(participant_address_bin)
if channel_state.contract_balance != event['balance']:
channel_state.update_contract_balance(event['balance'])
if channel.external_state.opened_block == 0:
channel.external_state.set_opened(event['block_number'])
def token_addresses(request, token_amount, number_of_tokens,
blockchain_services, cached_genesis, register_tokens):
if cached_genesis:
token_addresses = [
address_decoder(token_address)
for token_address in cached_genesis['config']['tokenAddresses']
]
else:
token_addresses = _token_addresses(
token_amount, number_of_tokens, blockchain_services.deploy_service,
blockchain_services.blockchain_services, register_tokens)
return token_addresses
def manager_address_by_token(self, token_address):
""" Return the channel manager address for the given token or None if
there is no correspoding address.
"""
address = self.proxy.channelManagerByToken.call(
token_address,
startgas=self.startgas,
)
if address == '':
check_address_has_code(self.client, self.address)
return None
return address_decoder(address)
def tester_state(deploy_key, private_keys, tester_blockgas_limit):
tester_state = tester.state()
# special addresses 1 to 5
alloc = {
int_to_addr(i): {'wei': 1}
for i in range(1, 5)
}
for privkey in [deploy_key] + private_keys:
address = privatekey_to_address(privkey)
alloc[address] = {
'balance': DEFAULT_BALANCE,
}
for account in tester.accounts:
alloc[account] = {
'balance': DEFAULT_BALANCE,
}
db = ethereum.db.EphemDB()
env = ethereum.config.Env(
db,
ethereum.config.default_config,
)
genesis_overwrite = {
'nonce': zpad(data_decoder('0x00006d6f7264656e'), 8),
'difficulty': quantity_decoder('0x20000'),
'mixhash': zpad(b'\x00', 32),
'coinbase': address_decoder('0x0000000000000000000000000000000000000000'),
'timestamp': 0,
'extra_data': b'',
'gas_limit': tester_blockgas_limit,
'start_alloc': alloc,
}
genesis_block = ethereum.blocks.genesis(
env,
**genesis_overwrite
)
# enable DELEGATECALL opcode
genesis_block.number = genesis_block.config['HOMESTEAD_FORK_BLKNUM'] + 1
tester_state.db = db
tester_state.env = env
tester_state.block = genesis_block
tester_state.blocks = [genesis_block]
return tester_state
def tester_state(deploy_key, private_keys, tester_blockgas_limit):
tester_state = tester.state()
# special addresses 1 to 5
alloc = {
int_to_addr(i): {'wei': 1}
for i in range(1, 5)
}
for privkey in [deploy_key] + private_keys:
address = privatekey_to_address(privkey)
alloc[address] = {
'balance': DEFAULT_BALANCE,
}
for account in tester.accounts:
alloc[account] = {
'balance': DEFAULT_BALANCE,
}
db = ethereum.db.EphemDB()
env = ethereum.config.Env(
db,
ethereum.config.default_config,
)
genesis_overwrite = {
'nonce': zpad(data_decoder('0x00006d6f7264656e'), 8),
'difficulty': quantity_decoder('0x20000'),
'mixhash': zpad(b'\x00', 32),
'coinbase': address_decoder('0x0000000000000000000000000000000000000000'),
'timestamp': 0,
'extra_data': b'',
'gas_limit': tester_blockgas_limit,
'start_alloc': alloc,
}
genesis_block = ethereum.blocks.genesis(
env,
**genesis_overwrite
)
# enable DELEGATECALL opcode
genesis_block.number = genesis_block.config['HOMESTEAD_FORK_BLKNUM'] + 1
tester_state.db = db
tester_state.env = env
tester_state.block = genesis_block
tester_state.blocks = [genesis_block]
return tester_state
def blockchain_services(
request,
deploy_key,
private_keys,
poll_timeout,
blockchain_backend, # This fixture is required because it will start
# the geth subprocesses
blockchain_rpc_ports,
blockchain_type,
tester_blockgas_limit,
cached_genesis):
verbose = request.config.option.verbose
if blockchain_type in ('geth', ):
registry_address = None
if cached_genesis:
registry_address = cached_genesis['config'].get(
'defaultRegistryAddress')
if registry_address:
registry_address = address_decoder(registry_address)
return _jsonrpc_services(
deploy_key,
private_keys,
verbose,
poll_timeout,
blockchain_rpc_ports[0],
registry_address,
)
if blockchain_type == 'tester':
return _tester_services(
deploy_key,
private_keys,
tester_blockgas_limit,
)
if blockchain_type == 'mock':
return _mock_services(
deploy_key,
private_keys,
request,
)
raise ValueError('unknown cluster type {}'.format(blockchain_type))
def assert_decoder_results(message, decoder):
message_encoded = message.encode()
transfer_raw, signing_address = decoder.getTransferRawAddress(message_encoded)
assert address_decoder(signing_address) == message.sender
assert transfer_raw == message_encoded[:-65]
(
nonce_decoded,
locksroot_decoded,
transferred_amount_decoded
) = decoder.decodeTransfer(transfer_raw)
assert message.nonce == nonce_decoded
assert message.transferred_amount == transferred_amount_decoded
assert message.locksroot == locksroot_decoded
def blockchain_services(
request,
deploy_key,
private_keys,
poll_timeout,
blockchain_backend, # This fixture is required because it will start
# the geth subprocesses
blockchain_rpc_ports,
blockchain_type,
tester_blockgas_limit,
cached_genesis):
verbose = request.config.option.verbose
if blockchain_type in ('geth',):
registry_address = None
if cached_genesis:
registry_address = cached_genesis['config'].get('defaultRegistryAddress')
if registry_address:
registry_address = address_decoder(registry_address)
return _jsonrpc_services(
deploy_key,
private_keys,
verbose,
poll_timeout,
blockchain_rpc_ports[0],
registry_address,
)
if blockchain_type == 'tester':
return _tester_services(
deploy_key,
private_keys,
tester_blockgas_limit,
)
if blockchain_type == 'mock':
return _mock_services(
deploy_key,
private_keys,
request,
)
raise ValueError('unknow cluster type {}'.format(blockchain_type))
def manager_by_asset(self, asset_address):
""" Find the channel manager for `asset_address` and return a proxy to
interact with it.
"""
if asset_address not in self.asset_manager:
asset = self.asset(asset_address) # check that the asset exists
manager_address = self.default_registry.manager_address_by_asset(asset.address)
manager = ChannelManager(
self.client,
address_decoder(manager_address),
poll_timeout=self.poll_timeout,
)
self.asset_manager[asset_address] = manager
self.address_manager[manager_address] = manager
return self.asset_manager[asset_address]
def manager_by_asset(self, asset_address):
""" Find the channel manager for `asset_address` and return a proxy to
interact with it.
"""
if asset_address not in self.asset_manager:
asset = self.asset(asset_address) # check that the asset exists
manager_address = self.default_registry.manager_address_by_asset(asset.address)
manager = ChannelManager(
self.client,
address_decoder(manager_address),
poll_timeout=self.poll_timeout,
)
self.asset_manager[asset_address] = manager
self.address_manager[manager_address] = manager
return self.asset_manager[asset_address]
def manager_by_token(self, token_address):
""" Find the channel manager for `token_address` and return a proxy to
interact with it.
"""
if token_address not in self.token_manager:
token = self.token(token_address) # check that the token exists
manager_address = self.default_registry.manager_address_by_token(token.address)
manager = ChannelManager(
self.client,
address_decoder(manager_address),
poll_timeout=self.poll_timeout,
)
self.token_manager[token_address] = manager
self.address_manager[manager_address] = manager
return self.token_manager[token_address]
def new_netting_channel(self, peer1, peer2, settle_timeout):
if not isaddress(peer1):
raise ValueError('The pee1 must be a valid address')
if not isaddress(peer2):
raise ValueError('The peer2 must be a valid address')
if privatekey_to_address(self.client.privkey) == peer1:
other = peer2
else:
other = peer1
transaction_hash = self.proxy.newChannel.transact(
other,
settle_timeout,
startgas=self.startgas,
gasprice=self.gasprice * 2,
)
self.client.poll(transaction_hash.decode('hex'),
timeout=self.poll_timeout)
# TODO: raise if the transaction failed because there is an existing
# channel in place
netting_channel_address_encoded = self.proxy.getChannelWith.call(
other,
startgas=self.startgas,
)
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)
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 get_filter_events(jsonrpc_client,
contract_address,
topics,
from_block=None,
to_block=None):
""" Custom new filter implementation to handle bad encoding from geth rpc. """
if isinstance(from_block, int):
from_block = hex(from_block)
if isinstance(to_block, int):
to_block = hex(to_block)
json_data = {
'fromBlock': from_block or hex(0),
'toBlock': to_block or 'latest',
'address': address_encoder(normalize_address(contract_address)),
}
if topics is not None:
json_data['topics'] = [topic_encoder(topic) for topic in topics]
filter_changes = jsonrpc_client.call('eth_getLogs', json_data)
# geth could return None
if filter_changes is None:
return []
result = []
for log_event in filter_changes:
address = address_decoder(log_event['address'])
data = data_decoder(log_event['data'])
topics = [decode_topic(topic) for topic in log_event['topics']]
block_number = log_event.get('blockNumber')
if not block_number:
block_number = 0
else:
block_number = int(block_number, 0)
result.append({
'topics': topics,
'data': data,
'address': address,
'block_number': block_number,
})
return result
def register_token(self, token_address):
"""Register a token with the raiden token manager.
Args:
token_address (string): a hex encoded token address.
Returns:
channel_manager: the channel_manager contract_proxy.
"""
# Add the ERC20 token to the raiden registry
self._chain.default_registry.add_token(token_address)
# Obtain the channel manager for the token
channel_manager = self._chain.manager_by_token(
address_decoder(token_address))
# Register the channel manager with the raiden registry
self._raiden.register_channel_manager(channel_manager)
return channel_manager
def endpoint_discovery_services(blockchain_services, blockchain_type, cached_genesis):
discovery_address = None
if cached_genesis and 'defaultDiscoveryAddress' in cached_genesis['config']:
discovery_address = address_decoder(
cached_genesis['config']['defaultDiscoveryAddress']
)
if discovery_address is None:
discovery_address = blockchain_services.deploy_service.deploy_contract(
'EndpointRegistry',
'EndpointRegistry.sol',
)
return [
ContractDiscovery(chain.node_address, chain.discovery(discovery_address))
for chain in blockchain_services.blockchain_services
]
def get_token_network_events(self, token_address, from_block, to_block=''):
# Note: Issue #452 (https://github.com/raiden-network/raiden/issues/452)
# tracks a suggested TODO, which will reduce the 3 RPC calls here to only
# one using `eth_getLogs`. It will require changes in all testing frameworks
# to be implemented though.
translator = ContractTranslator(CHANNEL_MANAGER_ABI)
token_address_bin = address_decoder(token_address)
channel_manager = self.raiden.chain.manager_by_token(token_address_bin)
filter_ = None
try:
filter_ = channel_manager.channelnew_filter(from_block, to_block)
events = filter_.getall()
finally:
if filter_ is not None:
filter_.uninstall()
return [
translator.decode_event(event['topics'], event['data'])
for event in events
]
def new_netting_channel(self, peer1, peer2, settle_timeout):
if not isaddress(peer1):
raise ValueError('The pee1 must be a valid address')
if not isaddress(peer2):
raise ValueError('The peer2 must be a valid address')
if privatekey_to_address(self.client.privkey) == peer1:
other = peer2
else:
other = peer1
transaction_hash = self.proxy.newChannel.transact(
other,
settle_timeout,
startgas=self.startgas,
gasprice=self.gasprice,
)
self.client.poll(transaction_hash.decode('hex'), timeout=self.poll_timeout)
# TODO: raise if the transaction failed because there is an existing
# channel in place
netting_channel_address_encoded = self.proxy.getChannelWith.call(
other,
startgas=self.startgas,
)
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)
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 _query_filter(self, function):
filter_changes = self.client.call(function, self.filter_id_raw)
# geth could return None
if filter_changes is None:
return []
result = list()
for log_event in filter_changes:
address = address_decoder(log_event['address'])
data = data_decoder(log_event['data'])
topics = [decode_topic(topic) for topic in log_event['topics']]
result.append({
'topics': topics,
'data': data,
'address': address,
})
return result
def manager_by_token(self, token_address):
""" Find the channel manager for `token_address` and return a proxy to
interact with it.
If the token is not already registered it raises `JSONRPCClientReplyError`,
since we try to instantiate a Channel manager with an empty address.
"""
if token_address not in self.token_manager:
token = self.token(token_address) # check that the token exists
manager_address = self.default_registry.manager_address_by_token(token.address)
manager = ChannelManager(
self.client,
address_decoder(manager_address),
poll_timeout=self.poll_timeout,
)
self.token_manager[token_address] = manager
self.address_manager[manager_address] = manager
return self.token_manager[token_address]
def assets_addresses(
request,
asset_amount,
number_of_assets,
blockchain_services,
cached_genesis):
if cached_genesis:
assets_addresses = [
address_decoder(asset_address)
for asset_address in cached_genesis['config']['assetAddresses']
]
else:
assets_addresses = _assets_addresses(
asset_amount,
number_of_assets,
blockchain_services.deploy_service,
blockchain_services.blockchain_services,
)
return assets_addresses
def add_asset(self, asset_address):
transaction_hash = self.proxy.addAsset.transact(
asset_address,
startgas=self.startgas,
)
self.client.poll(transaction_hash.decode('hex'), timeout=self.poll_timeout)
channel_manager_address_encoded = self.proxy.channelManagerByAsset.call(
asset_address,
startgas=self.startgas,
)
if not channel_manager_address_encoded:
log.error('add_asset failed', asset_address=pex(asset_address))
raise RuntimeError('add_asset failed')
channel_manager_address_bin = address_decoder(channel_manager_address_encoded)
log.info(
'add_asset called',
asset_address=pex(asset_address),
registry_address=pex(self.address),
channel_manager_address=pex(channel_manager_address_bin),
)
def asset_address(self):
asset_address_hex = self.proxy.tokenAddress()
self.tester_state.mine(number_of_blocks=1)
asset_address = address_decoder(asset_address_hex)
return asset_address
def event_assetadded(self, registry_address, event):
manager_address = address_decoder(event['channelManagerAddress'])
manager = self.raiden.chain.manager(manager_address)
self.raiden.register_channel_manager(manager)
def asset_addresses(self):
return [
address_decoder(address)
for address in self.proxy.assetAddresses.call(startgas=self.startgas)
]
def manager_addresses(self):
return [
address_decoder(address)
for address in self.proxy.channelManagerAddresses.call(startgas=self.startgas)
]
def asset_address(self):
""" Return the asset of this manager. """
return address_decoder(self.proxy.tokenAddress.call())
def partner(self, our_address):
result = address_decoder(self.proxy.partner(our_address))
self.tester_state.mine(number_of_blocks=1)
return result
def event_assetadded(self, registry_address_bin, event): # pylint: disable=unused-argument
manager_address_bin = address_decoder(event['channel_manager_address'])
manager = self.raiden.chain.manager(manager_address_bin)
self.raiden.register_channel_manager(manager)
def asset_address(self):
return address_decoder(self.proxy.assetAddress.call())
def asset_address(self):
result = address_decoder(self.proxy.assetAddress())
self.tester_state.mine(number_of_blocks=1)
return result
def coinbase(self):
return address_decoder(self.call('eth_coinbase'))
