def test_abicontract_interface():
""" Test for issue #370. """
tester_state = state()
contract_path = path.join(CONTRACTS_DIR, 'simple_contract.sol')
contract_name = 'Simple'
simple_compiled = compile_file(contract_path)
simple_data = solidity_get_contract_data(
simple_compiled,
contract_path,
contract_name,
)
simple_address = tester_state.evm(simple_data['bin'])
# ABIContract class must accept json_abi
abi_json = json.dumps(simple_data['abi']).encode('utf-8')
abi = ABIContract(
_state=tester_state,
_abi=abi_json,
address=simple_address,
listen=False,
log_listener=None,
default_key=None,
)
assert abi.test() == 1 # pylint: disable=no-member
def token(state, token_address, token_abi):
translator = ContractTranslator(token_abi)
return ABIContract(
state,
translator,
token_address,
)
def test_all_asset(asset_amount, state, channel, token, events):
half_amount = asset_amount / 2
assert token.transfer(tester.a1, half_amount) is True
token1 = ABIContract(
state,
token.translator,
token.address,
default_key=tester.k1,
)
assert token.approve(channel.address, half_amount) is True
assert token1.approve(channel.address, half_amount) is True
channel1 = ABIContract(
state,
channel.translator,
channel.address,
default_key=tester.k1,
)
channel.deposit(half_amount)
channel1.deposit(half_amount)
_, deposit1, _, deposit2 = channel.addressAndBalance()
assert deposit1 == half_amount
assert deposit2 == half_amount
assert token.balanceOf(channel.address) == asset_amount
assert token.balanceOf(tester.a0) == 0
assert token.balanceOf(tester.a1) == 0
def test_abicontract_interface():
""" Test for issue #370. """
tester_state = state()
contract_path = path.join(CONTRACTS_DIR, 'simple_contract.sol')
simple_compiled = compile_file(contract_path)
simple_address = tester_state.evm(simple_compiled['Simple']['bin'])
# ABIContract class must accept json_abi
abi_json = json.dumps(simple_compiled['Simple']['abi']).encode('utf-8')
abi = ABIContract(
_state=tester_state,
_abi=abi_json,
address=simple_address,
listen=False,
log_listener=None,
default_key=None,
)
assert abi.test() == 1 # pylint: disable=no-member
def contract_at(self, address, abi):
return ABIContract(self.s, abi, address)
def test_cmc(state, settle_timeout, netting_channel_abi, manager, events): # pylint: disable=too-many-locals,too-many-statements
address1 = sha3('address1')[:20]
address3 = sha3('address3')[:20]
inexisting_address = sha3('this_does_not_exist')[:20]
netting_channel_translator = ContractTranslator(netting_channel_abi)
assert len(manager.getChannelsParticipants()) == 0
netting_channel_address1_hex = manager.newChannel(
address1,
settle_timeout,
)
# cannot have two channels at the same time
with pytest.raises(TransactionFailed):
manager.newChannel(address1, settle_timeout)
# should trow if there is no channel for the given address
with pytest.raises(TransactionFailed):
manager.getChannelWith(inexisting_address)
assert len(manager.getChannelsParticipants()) == 2
netting_contract_proxy1 = ABIContract(
state,
netting_channel_translator,
netting_channel_address1_hex,
)
assert netting_contract_proxy1.settleTimeout() == settle_timeout
netting_channel_address2_hex = manager.newChannel(
address3,
settle_timeout,
)
assert manager.getChannelWith(address1) == netting_channel_address1_hex
assert manager.getChannelWith(address3) == netting_channel_address2_hex
msg_sender_channels = manager.nettingContractsByAddress(tester.DEFAULT_ACCOUNT)
address1_channels = manager.nettingContractsByAddress(address1)
inexisting_channels = manager.nettingContractsByAddress(inexisting_address)
assert len(msg_sender_channels) == 2
assert len(address1_channels) == 1
assert len(inexisting_channels) == 0
assert len(manager.getChannelsParticipants()) == 4
assert len(events) == 2
assert events[0]['_event_type'] == 'ChannelNew'
assert events[0]['participant1'] == tester.a0.encode('hex')
assert events[0]['participant2'] == address1.encode('hex')
assert events[0]['nettingChannel'] == netting_channel_address1_hex
assert events[0]['settleTimeout'] == 30
assert events[1]['_event_type'] == 'ChannelNew'
assert events[1]['participant1'] == tester.a0.encode('hex')
assert events[1]['participant2'] == address3.encode('hex')
assert events[1]['nettingChannel'] == netting_channel_address2_hex
assert events[1]['settleTimeout'] == 30
def test_channelmanager(tester_state, tester_token, tester_events,
tester_channelmanager_library_address, settle_timeout,
netting_channel_abi): # pylint: disable=too-many-locals,too-many-statements
address0 = tester.DEFAULT_ACCOUNT
address1 = tester.a1
address2 = tester.a2
nonexisting_address = sha3('this_does_not_exist')[:20]
channelmanager_path = get_contract_path('ChannelManagerContract.sol')
channel_manager = tester_state.abi_contract(
None,
path=channelmanager_path,
language='solidity',
constructor_parameters=[tester_token.address],
contract_name='ChannelManagerContract',
log_listener=tester_events.append,
libraries={
'ChannelManagerLibrary':
tester_channelmanager_library_address.encode('hex'),
})
participants_count = len(channel_manager.getChannelsParticipants())
assert participants_count == 0, 'newly deployed contract must be empty'
netting_channel_translator = ContractTranslator(netting_channel_abi)
previous_events = list(tester_events)
netting_channel_address1_hex = channel_manager.newChannel(
address1,
settle_timeout,
)
assert len(previous_events) + 1 == len(
tester_events), 'ChannelNew event must be fired.'
channelnew_event = tester_events[-1]
assert channelnew_event == {
'_event_type': 'ChannelNew',
'participant1': address0.encode('hex'),
'participant2': address1.encode('hex'),
'netting_channel': netting_channel_address1_hex,
'settle_timeout': settle_timeout,
}
# should fail if settleTimeout is too low
with pytest.raises(TransactionFailed):
channel_manager.newChannel(address1, 5)
# cannot have two channels at the same time
with pytest.raises(TransactionFailed):
channel_manager.newChannel(address1, settle_timeout)
# should be zero address if there is no channel for the given address
assert channel_manager.getChannelWith(nonexisting_address) == '0' * 40
assert len(channel_manager.getChannelsParticipants()) == 2
netting_contract_proxy1 = ABIContract(
tester_state,
netting_channel_translator,
netting_channel_address1_hex,
)
assert netting_contract_proxy1.settleTimeout() == settle_timeout
previous_events = list(tester_events)
netting_channel_address2_hex = channel_manager.newChannel(
address2,
settle_timeout,
)
assert len(previous_events) + 1 == len(
tester_events), 'ChannelNew event must be fired.'
assert channel_manager.getChannelWith(
address1) == netting_channel_address1_hex
assert channel_manager.getChannelWith(
address2) == netting_channel_address2_hex
msg_sender_channels = channel_manager.nettingContractsByAddress(
tester.DEFAULT_ACCOUNT)
address1_channels = channel_manager.nettingContractsByAddress(address1)
nonexisting_channels = channel_manager.nettingContractsByAddress(
nonexisting_address)
assert len(msg_sender_channels) == 2
assert len(address1_channels) == 1
assert len(nonexisting_channels) == 0
assert len(channel_manager.getChannelsParticipants()) == 4
channelnew_event = tester_events[-1]
assert channelnew_event == {
'_event_type': 'ChannelNew',
'participant1': address0.encode('hex'),
'participant2': address2.encode('hex'),
'netting_channel': netting_channel_address2_hex,
'settle_timeout': settle_timeout,
}
def test_reopen_channel(tester_state, tester_events, tester_channelmanager,
tester_channels, settle_timeout, netting_channel_abi):
privatekey0_raw, privatekey1_raw, nettingchannel, channel0, _ = tester_channels[
0]
privatekey0 = PrivateKey(privatekey0_raw)
address0 = privatekey_to_address(privatekey0_raw)
address1 = privatekey_to_address(privatekey1_raw)
address2 = tester.a2
# We need to close the channel before it can be deleted, to do so we need
# one transfer to pass in close()
transfer_amount = 10
identifier = 1
direct_transfer = channel0.create_directtransfer(
transfer_amount,
identifier,
)
direct_transfer.sign(privatekey0, address0)
direct_transfer_data = str(direct_transfer.packed().data)
should_be_nonce = nettingchannel.opened(sender=privatekey0_raw) * (2**32)
should_be_nonce_plus_one = (nettingchannel.opened(sender=privatekey0_raw) +
1) * (2**32)
assert should_be_nonce <= direct_transfer.nonce < should_be_nonce_plus_one
# settle the channel should not change the channel manager state
nettingchannel.close(
direct_transfer_data,
sender=privatekey1_raw,
)
tester_state.mine(number_of_blocks=settle_timeout + 1)
nettingchannel.settle(sender=privatekey0_raw)
tester_state.mine(1)
# now a single new channel can be opened
# if channel with address is settled a new can be opened
# old entry will be deleted when calling newChannel
netting_channel_address1_hex = tester_channelmanager.newChannel(
address1,
settle_timeout,
sender=privatekey0_raw,
)
channeldelete_event = tester_events[-2]
assert channeldelete_event == {
'_event_type': 'ChannelDeleted',
'caller_address': address0.encode('hex'),
'partner': address1.encode('hex')
}
netting_channel_translator = ContractTranslator(netting_channel_abi)
netting_contract_proxy1 = ABIContract(
tester_state,
netting_channel_translator,
netting_channel_address1_hex,
)
# transfer not in nonce range
with pytest.raises(TransactionFailed):
netting_contract_proxy1.close(
direct_transfer_data,
sender=privatekey0_raw,
)
# channel already exists
with pytest.raises(TransactionFailed):
tester_channelmanager.newChannel(
address1,
settle_timeout,
sender=privatekey0_raw,
)
# opening a new channel that did not exist before
tester_channelmanager.newChannel(
address2,
settle_timeout,
sender=privatekey0_raw,
)
def test_cmc(state, settle_timeout, netting_channel_abi, manager, events): # pylint: disable=too-many-locals,too-many-statements
address1 = sha3('address1')[:20]
address3 = sha3('address3')[:20]
inexisting_address = sha3('this_does_not_exist')[:20]
netting_channel_translator = ContractTranslator(netting_channel_abi)
assert len(manager.getChannelsParticipants()) == 0
netting_channel_address1_hex = manager.newChannel(
address1,
settle_timeout,
)
# cannot have two channels at the same time
with pytest.raises(TransactionFailed):
manager.newChannel(address1, settle_timeout)
# should trow if there is no channel for the given address
with pytest.raises(TransactionFailed):
manager.getChannelWith(inexisting_address)
assert len(manager.getChannelsParticipants()) == 2
netting_contract_proxy1 = ABIContract(
state,
netting_channel_translator,
netting_channel_address1_hex,
)
assert netting_contract_proxy1.settleTimeout() == settle_timeout
netting_channel_address2_hex = manager.newChannel(
address3,
settle_timeout,
)
assert manager.getChannelWith(address1) == netting_channel_address1_hex
assert manager.getChannelWith(address3) == netting_channel_address2_hex
msg_sender_channels = manager.nettingContractsByAddress(
tester.DEFAULT_ACCOUNT)
address1_channels = manager.nettingContractsByAddress(address1)
inexisting_channels = manager.nettingContractsByAddress(inexisting_address)
assert len(msg_sender_channels) == 2
assert len(address1_channels) == 1
assert len(inexisting_channels) == 0
assert len(manager.getChannelsParticipants()) == 4
assert len(events) == 2
assert events[0]['_event_type'] == 'ChannelNew'
assert events[0]['participant1'] == tester.a0.encode('hex')
assert events[0]['participant2'] == address1.encode('hex')
assert events[0]['nettingChannel'] == netting_channel_address1_hex
assert events[0]['settleTimeout'] == 30
assert events[1]['_event_type'] == 'ChannelNew'
assert events[1]['participant1'] == tester.a0.encode('hex')
assert events[1]['participant2'] == address3.encode('hex')
assert events[1]['nettingChannel'] == netting_channel_address2_hex
assert events[1]['settleTimeout'] == 30
def test_settle(state, channel, token, asset_amount, events):
half_amount = asset_amount / 2
assert token.transfer(tester.a1, half_amount) is True
token1 = ABIContract(
state,
token.translator,
token.address,
default_key=tester.k1,
)
assert token.approve(channel.address, half_amount) is True
assert token1.approve(channel.address, half_amount) is True
channel1 = ABIContract(
state,
channel.translator,
channel.address,
default_key=tester.k1,
)
channel.deposit(half_amount)
channel1.deposit(half_amount)
secret1 = 'x' * 32
hashlock1 = sha3(secret1)
lock_amount1 = 29
lock_expiration1 = 1158003
lock1 = Lock(lock_amount1, lock_expiration1, hashlock1)
lockhash1 = sha3(lock1.as_bytes)
merkleproof1 = [lockhash1]
locksroot1 = merkleroot([lockhash1], merkleproof1)
nonce1 = 1
asset = token.address
transfered_amount1 = 1
recipient = tester.a1
locksroot = locksroot1
msg1 = DirectTransfer(
nonce1,
asset,
transfered_amount1,
recipient,
locksroot,
)
msg1.sign(tester.k0)
packed = msg1.packed()
direct_transfer1 = str(packed.data)
secret2 = 'y' * 32
hashlock2 = sha3(secret2)
lock_amount2 = 20
lock_expiration2 = 1158005
lock2 = Lock(lock_amount2, lock_expiration2, hashlock2)
lockhash2 = sha3(lock2.as_bytes)
merkleproof2 = [lockhash2]
locksroot2 = merkleroot([lockhash2], merkleproof2)
locksroot = locksroot2
nonce2 = 2
transfered_amount2 = 3
msg2 = DirectTransfer(
nonce2,
token.address, # asset
transfered_amount2,
tester.a0, # recipient
locksroot,
)
msg2.sign(tester.k1)
packed = msg2.packed()
direct_transfer2 = str(packed.data)
# not yet closed. should fail
with pytest.raises(TransactionFailed):
channel.settle()
channel.close(direct_transfer1, direct_transfer2)
channel.unlock(
str(lock1.as_bytes),
''.join(merkleproof1),
secret1,
)
channel.unlock(str(lock2.as_bytes),
''.join(merkleproof2),
secret2,
sender=tester.k1)
secret4 = 'k' * 32
hashlock4 = sha3(secret4)
lock_amount4 = 23
lock_expiration4 = 31
lock4 = Lock(lock_amount4, lock_expiration4, hashlock4)
hashlock4 = sha3(lock4.as_bytes)
merkleproof4 = [hashlock4]
# has now message, should fail
with pytest.raises(TransactionFailed):
channel.unlock(
str(lock4.as_bytes),
''.join(merkleproof4),
secret4,
sender=tester.k1,
)
# still timeout
with pytest.raises(TransactionFailed):
channel.settle()
state.block.number = state.block.number + 40 # timeout over
channel.settle()
balance1 = half_amount + (transfered_amount2 -
transfered_amount1) + lock_amount1 - lock_amount2
balance2 = half_amount + (transfered_amount1 -
transfered_amount2) - lock_amount1 + lock_amount2
assert token.balanceOf(tester.a0) == balance1
assert token.balanceOf(tester.a1) == balance2
# can settle only once
with pytest.raises(TransactionFailed):
channel.settle()
assert len(events) == 6
assert events[0]['_event_type'] == 'ChannelNewBalance'
assert events[0]['assetAddress'] == token.address.encode('hex')
assert events[0]['participant'] == tester.a0.encode('hex')
assert events[0]['balance'] == 50
assert events[1]['_event_type'] == 'ChannelNewBalance'
assert events[1]['assetAddress'] == token.address.encode('hex')
assert events[1]['participant'] == tester.a1.encode('hex')
assert events[1]['balance'] == 50
assert events[2]['_event_type'] == 'ChannelClosed'
assert events[2]['closingAddress'] == tester.a0.encode('hex')
assert events[2]['blockNumber'] == 1158002
assert events[3]['_event_type'] == 'ChannelSecretRevealed'
assert events[3]['secret'] == 'x' * 32
assert events[4]['_event_type'] == 'ChannelSecretRevealed'
assert events[4]['secret'] == 'y' * 32
assert events[5]['_event_type'] == 'ChannelSettled'
assert events[5]['blockNumber'] == state.block.number
def test_channelmanager(
tester_state,
tester_token,
tester_events,
tester_channelmanager_library_address,
settle_timeout,
netting_channel_abi,
):
# pylint: disable=too-many-locals,too-many-statements
address0 = tester.DEFAULT_ACCOUNT
address1 = tester.a1
address2 = tester.a2
inexisting_address = sha3("this_does_not_exist")[:20]
channelmanager_path = get_contract_path("ChannelManagerContract.sol")
channel_manager = tester_state.abi_contract(
None,
path=channelmanager_path,
language="solidity",
constructor_parameters=[tester_token.address],
contract_name="ChannelManagerContract",
log_listener=tester_events.append,
libraries={"ChannelManagerLibrary": tester_channelmanager_library_address.encode("hex")},
)
participants_count = len(channel_manager.getChannelsParticipants())
assert participants_count == 0, "newly deployed contract must be empty"
netting_channel_translator = ContractTranslator(netting_channel_abi)
previous_events = list(tester_events)
netting_channel_address1_hex = channel_manager.newChannel(address1, settle_timeout)
assert len(previous_events) + 1 == len(tester_events), "ChannelNew event must be fired."
channelnew_event = tester_events[-1]
assert channelnew_event == {
"_event_type": "ChannelNew",
"participant1": address0.encode("hex"),
"participant2": address1.encode("hex"),
"netting_channel": netting_channel_address1_hex,
"settle_timeout": settle_timeout,
}
# should fail if settleTimeout is too low
with pytest.raises(TransactionFailed):
channel_manager.newChannel(address1, 5)
# cannot have two channels at the same time
with pytest.raises(TransactionFailed):
channel_manager.newChannel(address1, settle_timeout)
# should trow if there is no channel for the given address
with pytest.raises(TransactionFailed):
channel_manager.getChannelWith(inexisting_address)
assert len(channel_manager.getChannelsParticipants()) == 2
netting_contract_proxy1 = ABIContract(tester_state, netting_channel_translator, netting_channel_address1_hex)
assert netting_contract_proxy1.settleTimeout() == settle_timeout
previous_events = list(tester_events)
netting_channel_address2_hex = channel_manager.newChannel(address2, settle_timeout)
assert len(previous_events) + 1 == len(tester_events), "ChannelNew event must be fired."
assert channel_manager.getChannelWith(address1) == netting_channel_address1_hex
assert channel_manager.getChannelWith(address2) == netting_channel_address2_hex
msg_sender_channels = channel_manager.nettingContractsByAddress(tester.DEFAULT_ACCOUNT)
address1_channels = channel_manager.nettingContractsByAddress(address1)
inexisting_channels = channel_manager.nettingContractsByAddress(inexisting_address)
assert len(msg_sender_channels) == 2
assert len(address1_channels) == 1
assert len(inexisting_channels) == 0
assert len(channel_manager.getChannelsParticipants()) == 4
channelnew_event = tester_events[-1]
assert channelnew_event == {
"_event_type": "ChannelNew",
"participant1": address0.encode("hex"),
"participant2": address2.encode("hex"),
"netting_channel": netting_channel_address2_hex,
"settle_timeout": settle_timeout,
}
