def test_verification_overall_checksum():
""" Tamper with the overall checksum and see failures in verify_precompiled_checksums() """
manager = ContractManager(contracts_source_path())
manager.checksum_contracts()
manager.verify_precompiled_checksums(contracts_precompiled_path())
original_checksum = manager.overall_checksum
# We change the source code overall checksum
manager.overall_checksum += '2'
# Now the verification should fail
with pytest.raises(ContractManagerVerificationError):
manager.verify_precompiled_checksums(contracts_precompiled_path())
manager.overall_checksum = None
with pytest.raises(ContractManagerVerificationError):
manager.verify_precompiled_checksums(contracts_precompiled_path())
manager.overall_checksum = ''
with pytest.raises(ContractManagerVerificationError):
manager.verify_precompiled_checksums(contracts_precompiled_path())
checksum_fail = list(original_checksum)
# Replace the first char with a different one
checksum_fail[0] = list(filter(lambda x: x != checksum_fail[0], ['2', 'a']))[0]
manager.overall_checksum = "".join(checksum_fail)
with pytest.raises(ContractManagerVerificationError):
manager.verify_precompiled_checksums(contracts_precompiled_path())
manager.overall_checksum = original_checksum
manager.verify_precompiled_checksums(contracts_precompiled_path())
def test_verification_contracts_checksums():
""" Tamper with the contract checksums and see failures in verify_precompiled_checksums() """
manager = ContractManager(contracts_source_path())
manager.checksum_contracts()
manager.verify_precompiled_checksums(contracts_precompiled_path())
for contract, checksum in manager.contracts_checksums.items():
manager.contracts_checksums[contract] += '2'
with pytest.raises(ContractManagerVerificationError):
manager.verify_precompiled_checksums(contracts_precompiled_path())
manager.contracts_checksums[contract] = None
with pytest.raises(ContractManagerVerificationError):
manager.verify_precompiled_checksums(contracts_precompiled_path())
manager.contracts_checksums[contract] = ''
with pytest.raises(ContractManagerVerificationError):
manager.verify_precompiled_checksums(contracts_precompiled_path())
checksum_fail = list(checksum)
# Replace the first char with a different one
checksum_fail[0] = list(filter(lambda x: x != checksum_fail[0], ['2', 'a']))[0]
manager.contracts_checksums[contract] = "".join(checksum_fail)
with pytest.raises(ContractManagerVerificationError):
manager.verify_precompiled_checksums(contracts_precompiled_path())
manager.contracts_checksums[contract] = checksum
manager.verify_precompiled_checksums(contracts_precompiled_path())
def __init__(
self,
web3: Web3,
private_key: str,
gas_limit: int,
gas_price: int = 1,
wait: int = 10,
contracts_version: Optional[str] = None,
):
self.web3 = web3
self.private_key = private_key
self.wait = wait
self.owner = private_key_to_address(private_key)
self.transaction = {'from': self.owner, 'gas_limit': gas_limit}
if gas_price != 0:
self.transaction['gasPrice'] = gas_price * denoms.gwei
self.contracts_version = contracts_version
self.precompiled_path = contracts_precompiled_path(
self.contracts_version)
self.contract_manager = ContractManager(self.precompiled_path)
# Check that the precompiled data is correct
self.contract_manager = ContractManager(contracts_source_path())
self.contract_manager.checksum_contracts()
self.contract_manager.verify_precompiled_checksums(
self.precompiled_path)
def test_contract_manager_json(tmpdir):
""" Check the ABI in contracts.json """
precompiled_path = Path(str(tmpdir)).joinpath('contracts.json')
ContractManager(
contracts_source_path()).compile_contracts(precompiled_path)
# try to load contracts from a precompiled file
contract_manager_meta(precompiled_path)
def __init__(
self,
web3: Web3,
private_key: str,
gas_limit: int,
gas_price: int=1,
wait: int=10,
contracts_version: Optional[str]=None,
):
self.web3 = web3
self.wait = wait
self.owner = private_key_to_address(private_key)
self.transaction = {'from': self.owner, 'gas': gas_limit}
if gas_price != 0:
self.transaction['gasPrice'] = gas_price * denoms.gwei
self.contracts_version = contracts_version
self.precompiled_path = contracts_precompiled_path(self.contracts_version)
self.contract_manager = ContractManager(self.precompiled_path)
self.web3.middleware_stack.add(
construct_sign_and_send_raw_middleware(private_key),
)
# Check that the precompiled data matches the source code
# Only for current version, because this is the only one with source code
if self.contracts_version in [None, CONTRACTS_VERSION]:
contract_manager_source = ContractManager(contracts_source_path())
contract_manager_source.checksum_contracts()
contract_manager_source.verify_precompiled_checksums(self.precompiled_path)
else:
log.info('Skipped checks against the source code because it is not available.')
def test_paths():
for _, source_path in contracts_source_path().items():
assert source_path.exists()
assert contracts_precompiled_path().exists()
assert contracts_deployed_path(NETWORKNAME_TO_ID['rinkeby']).exists()
assert contracts_deployed_path(NETWORKNAME_TO_ID['ropsten']).exists()
assert contracts_deployed_path(NETWORKNAME_TO_ID['kovan']).exists()
def test_paths():
""" contracts_source_path() exists and contains the expected files """
for _, source_path in contracts_source_path().items():
assert source_path.exists()
assert contracts_precompiled_path().exists()
assert contracts_deployed_path(NETWORKNAME_TO_ID['rinkeby']).exists()
assert contracts_deployed_path(NETWORKNAME_TO_ID['ropsten']).exists()
assert contracts_deployed_path(NETWORKNAME_TO_ID['kovan']).exists()
def run(self):
from raiden_contracts.contract_manager import (
ContractManager,
contracts_precompiled_path,
contracts_source_path,
)
contract_manager = ContractManager(contracts_source_path())
contract_manager.compile_contracts(contracts_precompiled_path())
def run(self):
from raiden_contracts.contract_manager import (
ContractManager,
contracts_precompiled_path,
contracts_source_path,
)
manager = ContractManager(contracts_source_path())
manager.checksum_contracts()
manager.verify_precompiled_checksums(contracts_precompiled_path())
def test_current_development_version():
""" contracts_source_path() exists and contains the expected files """
contracts_version = CONTRACTS_VERSION
contract_names = [
'Utils',
'EndpointRegistry',
'SecretRegistry',
'TokenNetworkRegistry',
'TokenNetwork',
'MonitoringService',
'RaidenServiceBundle',
]
manager = ContractManager(contracts_precompiled_path(contracts_version))
assert manager.contracts_version == contracts_version
check_precompiled_content(manager, contract_names, PRECOMPILED_DATA_FIELDS)
for _, source_path in contracts_source_path().items():
assert source_path.exists()
assert contracts_precompiled_path().exists()
def test_contract_manager_compile():
""" Check the ABI in the sources """
contract_manager_meta(contracts_source_path())
def contracts_manager():
return ContractManager(contracts_source_path())
def etherscan_verify(chain_id, apikey, guid, contract_name):
contract_manager = ContractManager(contracts_precompiled_path())
source_path = contracts_source_path()
deployment_info = get_contracts_deployed(chain_id)
if chain_id == 3:
etherscan_api = 'https://api-ropsten.etherscan.io/api'
elif chain_id == 4:
etherscan_api = 'https://api-rinkeby.etherscan.io/api'
elif chain_id == 42:
etherscan_api = 'https://api-kovan.etherscan.io/api'
elif chain_id == 1:
etherscan_api = 'https://api.etherscan.io/api'
if guid:
guid_status(etherscan_api, guid)
return
if contract_name is None or contract_name == CONTRACT_ENDPOINT_REGISTRY:
path = source_path['raiden'].joinpath(
f'{CONTRACT_ENDPOINT_REGISTRY}.sol')
source = path.read_text()
constructor_args = ''
etherscan_verify_contract(
etherscan_api,
apikey,
contract_manager.contracts[CONTRACT_ENDPOINT_REGISTRY],
CONTRACT_ENDPOINT_REGISTRY,
deployment_info['contracts'][CONTRACT_ENDPOINT_REGISTRY],
source,
constructor_args,
)
if contract_name is None or contract_name == CONTRACT_SECRET_REGISTRY:
path = source_path['raiden'].joinpath(
f'{CONTRACT_SECRET_REGISTRY}.sol')
source = path.read_text()
constructor_args = ''
etherscan_verify_contract(
etherscan_api,
apikey,
contract_manager.contracts[CONTRACT_SECRET_REGISTRY],
CONTRACT_SECRET_REGISTRY,
deployment_info['contracts'][CONTRACT_SECRET_REGISTRY],
source,
constructor_args,
)
if contract_name is None or contract_name == CONTRACT_TOKEN_NETWORK_REGISTRY:
source = (
source_path['raiden'].joinpath('Utils.sol').read_text() +
source_path['raiden'].joinpath('Token.sol').read_text() +
source_path['raiden'].joinpath('lib', 'ECVerify.sol').read_text() +
source_path['raiden'].joinpath('SecretRegistry.sol').read_text() +
source_path['raiden'].joinpath('TokenNetwork.sol').read_text() +
source_path['raiden'].joinpath(
'TokenNetworkRegistry.sol').read_text())
source = 'pragma solidity ^0.4.23;' + source.replace(
'pragma solidity ^0.4.23;', '')
source = source.replace('import "raiden/Token.sol";\n', '')
source = source.replace('import "raiden/Utils.sol";\n', '')
source = source.replace('import "raiden/lib/ECVerify.sol";\n', '')
source = source.replace('import "raiden/SecretRegistry.sol";\n', '')
source = source.replace('import "raiden/TokenNetwork.sol";\n', '')
flatten_path = Path(__file__).parent.joinpath('flatten.sol')
flatten_path.open('w').write(source)
constructor_arguments = deployment_info['contracts'][
CONTRACT_TOKEN_NETWORK_REGISTRY]['constructor_arguments']
abi = contract_manager.contracts[CONTRACT_TOKEN_NETWORK_REGISTRY][
'abi']
constructor_types = [
arg['type']
for arg in list(filter(lambda x: x['type'] == 'constructor', abi),
)[0]['inputs']
]
constructor_args = encode_abi(constructor_types,
constructor_arguments).hex()
print('constructor_args', constructor_arguments, constructor_types,
constructor_args)
etherscan_verify_contract(
etherscan_api,
apikey,
contract_manager.contracts[CONTRACT_TOKEN_NETWORK_REGISTRY],
CONTRACT_TOKEN_NETWORK_REGISTRY,
deployment_info['contracts'][CONTRACT_TOKEN_NETWORK_REGISTRY],
source,
constructor_args,
)
def test_contract_manager_compile():
contract_manager_meta(contracts_source_path())
