def deploy_contract( web3, contracts_compiled_data, contract_name, transaction, txn_wait=200, args=[] ): contract_interface = contracts_compiled_data[contract_name] # Instantiate and deploy contract contract = web3.eth.contract( abi=contract_interface['abi'], bytecode=contract_interface['bytecode'] ) # Get transaction hash from deployed contract txhash = contract.deploy(transaction=transaction, args=args) # Get tx receipt to get contract address receipt = check_succesful_tx(web3, txhash, txn_wait) print('{0} address: {1}. Gas used: {2}'.format( contract_name, receipt['contractAddress'], receipt['gasUsed']) ) return receipt['contractAddress']
def register_token_network( web3: Web3, private_key: str, token_registry_abi: Dict, token_registry_address: str, token_address: str, wait=10, gas_limit=4000000, ): """Register token with a TokenNetworkRegistry contract.""" token_network_registry = web3.eth.contract( abi=token_registry_abi, address=token_registry_address, ) token_network_registry = PrivateContract(token_network_registry) txhash = token_network_registry.functions.createERC20TokenNetwork( token_address, ).transact( {'gas_limit': gas_limit}, private_key=private_key, ) log.debug( "calling createERC20TokenNetwork(%s) txHash=%s" % ( token_address, encode_hex(txhash), ), ) receipt = check_succesful_tx(web3, txhash, wait) print( 'TokenNetwork address: {0} Gas used: {1}'.format( token_network_registry.functions.token_to_token_networks( token_address).call(), receipt['gasUsed'], ), )
def deploy( self, contract_name: str, args=None, ): if args is None: args = list() contract_interface = self.contract_manager.get_contract( contract_name, ) # Instantiate and deploy contract contract = self.web3.eth.contract( abi=contract_interface['abi'], bytecode=contract_interface['bin'], ) contract = PrivateContract(contract) # Get transaction hash from deployed contract txhash = self.send_deployment_transaction(contract, args) # Get tx receipt to get contract address log.debug("Deploying %s txHash=%s" % (contract_name, encode_hex(txhash))) receipt = check_succesful_tx(self.web3, txhash, self.wait) log.info( '{0} address: {1}. Gas used: {2}'.format( contract_name, receipt['contractAddress'], receipt['gasUsed'], ), ) return receipt
def deploy_contract( web3, contracts_compiled_data, contract_name, transaction, txn_wait=200, args=None, ): contract_interface = contracts_compiled_data[contract_name] # Instantiate and deploy contract contract = web3.eth.contract( abi=contract_interface['abi'], bytecode=contract_interface['bin'], ) log.info(f'Deploying {contract_name}') # Get transaction hash from deployed contract txhash = contract.deploy(transaction=transaction, args=args) # Get tx receipt to get contract address log.debug(f"TxHash: {txhash}") receipt = check_succesful_tx(web3, txhash, txn_wait) log.info( '{0} address: {1}. Gas used: {2}'.format( contract_name, receipt['contractAddress'], receipt['gasUsed'], ), ) return receipt['contractAddress']
def deprecation_test( ctx, private_key, rpc_provider, wait, gas_price, gas_limit, ): setup_ctx(ctx, private_key, rpc_provider, wait, gas_price, gas_limit) deployer = ctx.obj['deployer'] # We deploy the Raiden Network contracts and register a token network token_amount = MAX_ETH_CHANNEL_PARTICIPANT * 6 ( token_network_registry, token_network, token_contract, ) = deprecation_test_setup(deployer, token_amount) log.info('Checking that channels can be opened and deposits can be made.') # Check that we can open channels and deposit on behalf of A and B # Some arbitrary Ethereum addresses A = '0x6AA63296FA94975017244769F00F0c64DB7d7115' B = '0xc9a4fad99B6d7D3e48D18d2585470cd8f27FA61e' channel_identifier = open_and_deposit(A, B, token_network, deployer) log.info('Seding transaction to activate the deprecation switch.') # Activate deprecation switch txhash = token_network.functions.deprecate().transact( deployer.transaction, private_key=deployer.private_key, ) log.debug(f'Deprecation txHash={encode_hex(txhash)}') check_succesful_tx(deployer.web3, txhash, deployer.wait) assert token_network.functions.safety_deprecation_switch().call() is True log.info( 'Checking that channels cannot be opened anymore and no more deposits are allowed.' ) # Check that we cannot open more channels or deposit C = '0x5a23cedB607684118ccf7906dF3e24Efd2964719' D = '0x3827B9cDc68f061aa614F1b97E23664ef3b9220A' open_and_deposit(C, D, token_network, deployer, channel_identifier, False) log.info('Deprecation switch test OK.')
def main(**kwargs): rpc_provider = kwargs['rpc_provider'] json_file = kwargs['json'] owner = kwargs['owner'] supply = kwargs['supply'] token_name = kwargs['token_name'] token_decimals = kwargs['token_decimals'] token_symbol = kwargs['token_symbol'] token_address = kwargs['token_address'] supply *= 10**(token_decimals) txn_wait = kwargs['wait'] gas_price = kwargs['gas_price'] print('''Make sure chain is running, you can connect to it and it is synced, or you'll get timeout''') web3 = Web3(HTTPProvider(rpc_provider, request_kwargs={'timeout': 60})) print('Web3 provider is', web3.providers[0]) owner = owner or web3.eth.accounts[0] assert owner and is_address(owner), 'Invalid owner provided.' owner = to_checksum_address(owner) print('Owner is', owner) assert web3.eth.getBalance(owner) > 0, 'Account with insuficient funds.' transaction = {'from': owner} if gas_price == 0: transaction['gasPrice'] = gas_price with open(json_file) as json_data: contracts_compiled_data = json.load(json_data) if not token_address: token_address = deploy_contract( web3, contracts_compiled_data, 'CustomToken', transaction, txn_wait, [supply, token_decimals, token_name, token_symbol] ) assert token_address and is_address(token_address) token_address = to_checksum_address(token_address) secret_registry_address = deploy_contract( web3, contracts_compiled_data, 'SecretRegistry', transaction, txn_wait ) token_network_registry_address = deploy_contract( web3, contracts_compiled_data, 'TokenNetworksRegistry', transaction, txn_wait, [secret_registry_address, int(web3.version.network)] ) token_network_registry = instantiate_contract( web3, contracts_compiled_data, 'TokenNetworksRegistry', token_network_registry_address ) txhash = token_network_registry.transact(transaction).createERC20TokenNetwork( token_address ) receipt = check_succesful_tx(web3, txhash, txn_wait) print('TokenNetwork address: {0}. Gas used: {1}'.format( token_network_registry.call().token_to_token_networks(token_address), receipt['gasUsed']) )
def main( rpc_provider, owner, wait, gas_price, gas_limit, deploy_token, supply, token_name, token_decimals, token_symbol, token_address, ): supply *= 10**token_decimals logging.basicConfig(level=logging.DEBUG) logging.getLogger('web3').setLevel(logging.INFO) logging.getLogger('urllib3').setLevel(logging.INFO) web3 = Web3(HTTPProvider(rpc_provider, request_kwargs={'timeout': 60})) web3.middleware_stack.inject(geth_poa_middleware, layer=0) print('Web3 provider is', web3.providers[0]) owner = owner or web3.eth.accounts[0] assert owner and is_address(owner), 'Invalid owner provided.' owner = to_checksum_address(owner) print('Owner is', owner) assert web3.eth.getBalance(owner) > 0, 'Account with insuficient funds.' password = getpass(f'Enter password for {owner}:') transaction = {'from': owner, 'gas': gas_limit} if gas_price != 0: transaction['gasPrice'] = gas_price * 10**9 contract_manager = ContractManager(CONTRACTS_SOURCE_DIRS) contract_manager._compile_all_contracts() contracts_compiled_data = contract_manager._contracts deployed_contracts = {} web3.personal.unlockAccount(owner, password) deployed_contracts[CONTRACT_ENDPOINT_REGISTRY] = deploy_contract( web3, contracts_compiled_data, CONTRACT_ENDPOINT_REGISTRY, transaction, wait, ) web3.personal.unlockAccount(owner, password) secret_registry_address = deploy_contract( web3, contracts_compiled_data, CONTRACT_SECRET_REGISTRY, transaction, wait, ) deployed_contracts[CONTRACT_SECRET_REGISTRY] = secret_registry_address web3.personal.unlockAccount(owner, password) token_network_registry_address = deploy_contract( web3, contracts_compiled_data, CONTRACT_TOKEN_NETWORK_REGISTRY, transaction, wait, [ secret_registry_address, int(web3.version.network), DEPLOY_SETTLE_TIMEOUT_MIN, DEPLOY_SETTLE_TIMEOUT_MAX, ], ) deployed_contracts[ CONTRACT_TOKEN_NETWORK_REGISTRY] = token_network_registry_address if deploy_token: if not token_address: web3.personal.unlockAccount(owner, password) deployed_contracts[ 'CustomToken'] = token_address = deploy_contract( web3, contracts_compiled_data, 'CustomToken', transaction, wait, [supply, token_decimals, token_name, token_symbol], ) assert token_address and is_address(token_address) token_address = to_checksum_address(token_address) token_network_registry = instantiate_contract( web3, contracts_compiled_data, CONTRACT_TOKEN_NETWORK_REGISTRY, token_network_registry_address, ) web3.personal.unlockAccount(owner, password) txhash = token_network_registry.transact( transaction).createERC20TokenNetwork(token_address, ) receipt = check_succesful_tx(web3, txhash, wait) print( 'TokenNetwork address: {0}. Gas used: {1}'.format( token_network_registry.functions.token_to_token_networks( token_address).call(), receipt['gasUsed'], ), ) print(json.dumps(deployed_contracts, indent=4))
def open_and_deposit( A, B, token_network, deployer, channel_identifier=None, txn_success_status=True, ): try: txhash = token_network.functions.openChannel( A, B, DEPLOY_SETTLE_TIMEOUT_MIN).transact( deployer.transaction, private_key=deployer.private_key, ) log.debug( f'Opening a channel between {A} and {B} txHash={encode_hex(txhash)}' ) check_succesful_tx(deployer.web3, txhash, deployer.wait) # Get the channel identifier channel_identifier = token_network.functions.getChannelIdentifier( A, B).call() success_status = True except ValueError as ex: success_status = False log.info(f'Cannot open a new channel {ex}') assert txn_success_status == success_status, \ f'openChannel txn status is {success_status} instead of {txn_success_status}' assert channel_identifier is not None try: txhash = token_network.functions.setTotalDeposit( channel_identifier, A, int(MAX_ETH_CHANNEL_PARTICIPANT / 2), B, ).transact( deployer.transaction, private_key=deployer.private_key, ) log.debug( f'Depositing {MAX_ETH_CHANNEL_PARTICIPANT} tokens for {A} in a channel with ' f'identifier={channel_identifier} and partner= {B} txHash={encode_hex(txhash)}', ) check_succesful_tx(deployer.web3, txhash, deployer.wait) success_status = True except ValueError as ex: success_status = False log.info( f'Cannot deposit more tokens in channel={channel_identifier}, {ex}' ) assert txn_success_status == success_status, \ f'setTotalDeposit txn status is {success_status} instead of {txn_success_status}' try: txhash = token_network.functions.setTotalDeposit( channel_identifier, B, int(MAX_ETH_CHANNEL_PARTICIPANT / 2), A, ).transact( deployer.transaction, private_key=deployer.private_key, ) log.debug( f'Depositing {MAX_ETH_CHANNEL_PARTICIPANT} tokens for {B} in a channel with ' f'identifier={channel_identifier} and partner= {A} txHash={encode_hex(txhash)}', ) check_succesful_tx(deployer.web3, txhash, deployer.wait) success_status = True except ValueError as ex: success_status = False log.info( f'Cannot deposit more tokens in channel={channel_identifier}, {ex}' ) assert txn_success_status == success_status, \ f'setTotalDeposit txn status is {success_status} instead of {txn_success_status}' return channel_identifier
def deprecation_test_setup(deployer, token_amount): deployed_contracts = deploy_raiden_contracts(deployer)['contracts'] token_network_registry_abi = deployer.contract_manager.get_contract_abi( CONTRACT_TOKEN_NETWORK_REGISTRY, ) token_network_registry = deployer.web3.eth.contract( abi=token_network_registry_abi, address=deployed_contracts[CONTRACT_TOKEN_NETWORK_REGISTRY]['address'], ) token_network_registry = PrivateContract(token_network_registry) token_decimals = 18 multiplier = 10**token_decimals token_supply = 10**6 * multiplier token_amount = int(token_amount * multiplier) deployed_token = deploy_token_contract( deployer, token_supply, token_decimals, 'TestToken', 'TTT', CONTRACT_CUSTOM_TOKEN, ) token_address = deployed_token[CONTRACT_CUSTOM_TOKEN] token_abi = deployer.contract_manager.get_contract_abi( CONTRACT_CUSTOM_TOKEN) token_contract = deployer.web3.eth.contract( abi=token_abi, address=token_address, ) token_contract = PrivateContract(token_contract) # Mint some tokens for the owner txhash = token_contract.functions.mint(token_amount).transact( deployer.transaction, private_key=deployer.private_key, ) log.debug(f'Minting tokens txHash={encode_hex(txhash)}') check_succesful_tx(deployer.web3, txhash, deployer.wait) assert token_contract.functions.balanceOf( deployer.owner).call() >= token_amount abi = deployer.contract_manager.get_contract_abi( CONTRACT_TOKEN_NETWORK_REGISTRY) token_network_address = register_token_network( web3=deployer.web3, private_key=deployer.private_key, token_registry_abi=abi, token_registry_address=deployed_contracts[ CONTRACT_TOKEN_NETWORK_REGISTRY]['address'], token_address=token_address, wait=deployer.wait, ) token_network_abi = deployer.contract_manager.get_contract_abi( CONTRACT_TOKEN_NETWORK) token_network = deployer.web3.eth.contract( abi=token_network_abi, address=token_network_address, ) token_network = PrivateContract(token_network) log.info( f'Registered the token and created a TokenNetwork contract at {token_network_address}.', ) txhash = token_contract.functions.approve( token_network.address, token_amount).transact( deployer.transaction, private_key=deployer.private_key, ) log.debug( f'Aproving tokens for the TokenNetwork contract txHash={encode_hex(txhash)}' ) check_succesful_tx(deployer.web3, txhash, deployer.wait) assert token_contract.functions.allowance( deployer.owner, token_network.address, ).call() >= token_amount log.info( f'Approved {token_amount} tokens for the TokenNetwork contract ' f'from owner {deployer.owner}.', ) return (token_network_registry, token_network, token_contract)