def add_token_network_listener(
self,
token_network_proxy,
from_block: typing.BlockSpecification = 'latest',
):
channel_new_filter = token_network_proxy.channelnew_filter(from_block=from_block)
token_network_address = token_network_proxy.address
self.add_event_listener(
'TokenNetwork {}'.format(pex(token_network_address)),
channel_new_filter,
CONTRACT_MANAGER.get_contract_abi(CONTRACT_TOKEN_NETWORK),
)
def add_registry_listener(
self,
registry_proxy,
from_block: typing.BlockSpecification = 'latest',
):
tokenadded = registry_proxy.tokenadded_filter(from_block)
registry_address = registry_proxy.address
self.add_event_listener(
'Registry {}'.format(pex(registry_address)),
tokenadded,
CONTRACT_MANAGER.get_contract_abi(CONTRACT_REGISTRY),
)
def add_netting_channel_listener(
self,
netting_channel_proxy,
from_block: typing.BlockSpecification = 'latest',
):
netting_channel_events = netting_channel_proxy.all_events_filter(from_block)
channel_address = netting_channel_proxy.address
self.add_event_listener(
'NettingChannel Event {}'.format(pex(channel_address)),
netting_channel_events,
CONTRACT_MANAGER.get_contract_abi(CONTRACT_NETTING_CHANNEL),
)
def add_channel_manager_listener(
self,
channel_manager_proxy,
from_block: typing.BlockSpecification = 'latest',
):
channelnew = channel_manager_proxy.channelnew_filter(from_block)
manager_address = channel_manager_proxy.address
self.add_event_listener(
'ChannelManager {}'.format(pex(manager_address)),
channelnew,
CONTRACT_MANAGER.get_contract_abi(CONTRACT_CHANNEL_MANAGER),
)
def get_all_registry_events(
chain: BlockChainService,
registry_address: Address,
events: List[str] = ALL_EVENTS,
from_block: BlockSpecification = 0,
to_block: BlockSpecification = 'latest',
) -> List[Dict]:
""" Helper to get all events of the Registry contract at `registry_address`. """
return get_contract_events(
chain,
CONTRACT_MANAGER.get_contract_abi(CONTRACT_REGISTRY),
registry_address,
events,
from_block,
to_block,
)
def get_all_registry_events(chain,
registry_address,
events=ALL_EVENTS,
from_block=0,
to_block='latest'):
""" Helper to get all events of the Registry contract at
`registry_address`.
"""
return get_contract_events(
chain,
CONTRACT_MANAGER.get_contract_abi(CONTRACT_REGISTRY),
registry_address,
events,
from_block,
to_block,
)
def get_all_channel_manager_events(
chain: BlockChainService,
channel_manager_address: Address,
events: List[str] = ALL_EVENTS,
from_block: BlockSpecification = 0,
to_block: BlockSpecification = 'latest',
) -> List[Dict]:
""" Helper to get all events of the ChannelManagerContract at `token_address`. """
return get_contract_events(
chain,
CONTRACT_MANAGER.get_contract_abi(CONTRACT_CHANNEL_MANAGER),
channel_manager_address,
events,
from_block,
to_block,
)
def get_all_netting_channel_events(
chain: BlockChainService,
netting_channel_address: Address,
events: List[str] = ALL_EVENTS,
from_block: BlockSpecification = 0,
to_block: BlockSpecification = 'latest',
) -> List[Dict]:
""" Helper to get all events of a NettingChannelContract. """
return get_contract_events(
chain,
CONTRACT_MANAGER.get_contract_abi(CONTRACT_NETTING_CHANNEL),
netting_channel_address,
events,
from_block,
to_block,
)
def get_all_channel_manager_events(chain,
channel_manager_address,
events=ALL_EVENTS,
from_block=0,
to_block='latest'):
""" Helper to get all events of the ChannelManagerContract at
`token_address`.
"""
return get_contract_events(
chain,
CONTRACT_MANAGER.get_contract_abi(CONTRACT_CHANNEL_MANAGER),
channel_manager_address,
events,
from_block,
to_block,
)
def get_all_netting_channel_events(chain,
netting_channel_address,
events=ALL_EVENTS,
from_block=0,
to_block='latest'):
""" Helper to get all events of a NettingChannelContract at
`channel_identifier`.
"""
return get_contract_events(
chain,
CONTRACT_MANAGER.get_contract_abi(CONTRACT_NETTING_CHANNEL),
netting_channel_address,
events,
from_block,
to_block,
)
def __init__(
self,
jsonrpc_client,
token_address,
):
contract = jsonrpc_client.new_contract(
CONTRACT_MANAGER.get_contract_abi(CONTRACT_HUMAN_STANDARD_TOKEN),
to_normalized_address(token_address),
)
self.proxy = ContractProxy(jsonrpc_client, contract)
if not is_binary_address(token_address):
raise ValueError('token_address must be a valid address')
check_address_has_code(jsonrpc_client, token_address, 'Token')
self.address = token_address
self.client = jsonrpc_client
def __init__(self,
jsonrpc_client,
token_address,
poll_timeout=DEFAULT_POLL_TIMEOUT):
if not isaddress(token_address):
raise ValueError('token_address must be a valid address')
check_address_has_code(jsonrpc_client, token_address, 'Token')
proxy = jsonrpc_client.new_contract_proxy(
CONTRACT_MANAGER.get_contract_abi(CONTRACT_HUMAN_STANDARD_TOKEN),
address_encoder(token_address),
)
self.address = token_address
self.proxy = proxy
self.client = jsonrpc_client
self.poll_timeout = poll_timeout
def __init__(self,
jsonrpc_client,
discovery_address,
poll_timeout=DEFAULT_POLL_TIMEOUT):
if not isaddress(discovery_address):
raise ValueError('discovery_address must be a valid address')
check_address_has_code(jsonrpc_client, discovery_address, 'Discovery')
proxy = jsonrpc_client.new_contract_proxy(
CONTRACT_MANAGER.get_contract_abi(CONTRACT_ENDPOINT_REGISTRY),
address_encoder(discovery_address),
)
CONTRACT_MANAGER.check_contract_version(
proxy.call('contract_version').decode(),
CONTRACT_ENDPOINT_REGISTRY)
self.address = discovery_address
self.proxy = proxy
self.client = jsonrpc_client
self.poll_timeout = poll_timeout
self.not_found_address = NULL_ADDRESS
def __init__(
self,
jsonrpc_client,
channel_address,
poll_timeout=DEFAULT_POLL_TIMEOUT):
self.address = channel_address
self.client = jsonrpc_client
self.poll_timeout = poll_timeout
# Prevents concurrent deposit, close, or settle operations on the same channel
self.channel_operations_lock = RLock()
self.client = jsonrpc_client
self.node_address = privatekey_to_address(self.client.privkey)
self.proxy = jsonrpc_client.new_contract_proxy(
CONTRACT_MANAGER.get_contract_abi(CONTRACT_NETTING_CHANNEL),
address_encoder(channel_address),
)
CONTRACT_MANAGER.check_contract_version(
self.proxy.call('contract_version').decode(),
CONTRACT_NETTING_CHANNEL)
# check we are a participant of the given channel
self.detail()
self._check_exists()
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 test_blockchain(
blockchain_backend, # required to start the geth backend pylint: disable=unused-argument
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,
)
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,
)
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,
)
log_list = jsonrpc_client.web3.eth.getLogs(
{
'fromBlock': 0,
'toBlock': 'latest',
'topics': [],
}, )
assert not log_list
assert token_proxy.call('balanceOf', address) == total_token
transaction_hash = registry_proxy.transact(
'addToken',
address,
token_proxy.contract_address,
)
jsonrpc_client.poll(unhexlify(transaction_hash), timeout=poll_timeout)
assert len(registry_proxy.call('tokenAddresses')) == 1
log_list = jsonrpc_client.web3.eth.getLogs(
{
'fromBlock': 0,
'toBlock': 'latest',
'topics': [],
}, )
assert len(log_list) == 1
channel_manager_address_encoded = registry_proxy.call(
'channelManagerByToken',
token_proxy.contract_address,
)
channel_manager_address = to_canonical_address(
channel_manager_address_encoded)
log = log_list[0]
event = registry_proxy.decode_event(log)
event_args = event['args']
assert channel_manager_address == to_canonical_address(
event_args['channel_manager_address'])
assert token_proxy.contract_address == to_canonical_address(
event_args['token_address'])
channel_manager_proxy = jsonrpc_client.new_contract_proxy(
CONTRACT_MANAGER.get_contract_abi(CONTRACT_CHANNEL_MANAGER),
channel_manager_address,
)
transaction_hash = channel_manager_proxy.transact(
'newChannel',
addresses[1],
10,
)
jsonrpc_client.poll(unhexlify(transaction_hash), timeout=poll_timeout)
log_list = jsonrpc_client.web3.eth.getLogs(
{
'fromBlock': 0,
'toBlock': 'latest',
'topics': [],
}, )
assert len(log_list) == 2
