def deploy_client(request, populus_config): client_type = populus_config.get_value(request, 'deploy_client_type') if client_type == 'ethtester': from populus.ethtester_client import EthTesterClient client = EthTesterClient() elif client_type == 'rpc': from eth_rpc_client import Client rpc_host = populus_config.get_value(request, 'deploy_client_rpc_host') rpc_port = populus_config.get_value(request, 'deploy_client_rpc_port') client = Client(rpc_host, rpc_port) elif client_type == 'ipc': from eth_ipc_client import Client ipc_path = populus_config.get_value(request, 'ipc_path') if ipc_path is None: from populus.geth import get_geth_data_dir geth_project_dir = populus_config.get_value(request, 'geth_project_dir') geth_chain_name = populus_config.get_value(request, 'geth_chain_name') geth_data_dir = get_geth_data_dir(geth_project_dir, geth_chain_name) ipc_path = os.path.join(geth_data_dir, 'geth.ipc') client = Client(ipc_path) else: raise ValueError( "Unsupported client type '{0}'. Supported values are 'tester', " "'rpc', and 'ipc'" ) return client
def get_client(name): if len(clients) == 0: clients.update({ name: Client(host=node['host'], port=node['port']) for name, node in get_nodes().iteritems() }) return clients[name]
def test_new_filter(rpc_server, eth_coinbase): """ """ client = Client(CLIENT_HOST, CLIENT_PORT) filt_id = client.new_filter(from_block="latest", to_block="pending") assert is_valid_filter_id(filt_id)
def test_running_node_without_mining(project_test04, open_port): data_dir = get_geth_data_dir(project_test04, 'default') command, proc = run_geth_node(data_dir, rpc_port=open_port, mine=False) wait_for_popen(proc) rpc_client = Client('127.0.0.1', port=open_port) coinbase = rpc_client.get_coinbase() proc.send_signal(signal.SIGINT) wait_for_popen(proc) assert coinbase == get_geth_accounts(data_dir)[0]
def ipc_client(request, populus_config): from eth_ipc_client import Client ipc_path = populus_config.get_value(request, 'ipc_path') if ipc_path is None: from populus.geth import get_geth_data_dir geth_project_dir = populus_config.get_value(request, 'geth_project_dir') geth_chain_name = populus_config.get_value(request, 'geth_chain_name') geth_data_dir = get_geth_data_dir(geth_project_dir, geth_chain_name) ipc_path = os.path.join(geth_data_dir, 'geth.ipc') client = Client(ipc_path) return client
def test_get_filter_changes(rpc_server, eth_coinbase): """ """ client = Client(CLIENT_HOST, CLIENT_PORT) filt_id = client.new_filter() assert is_valid_filter_id(filt_id) resp = client.get_filter_logs(filt_id) assert resp == []
def test_uninstall_filter(rpc_server, eth_coinbase): """ """ client = Client(CLIENT_HOST, CLIENT_PORT) filt_id = client.new_filter() assert is_valid_filter_id(filt_id) resp = client.uninstall_filter(filt_id) assert resp == True
def test_send_a_transaction_uses_coinbase_as_from(rpc_server, eth_coinbase): client = Client('127.0.0.1', '8545') to_addr = tester.encode_hex(tester.accounts[1]) txn_hash = client.send_transaction( to=to_addr, value=12345, ) after_balance = client.get_balance(eth_coinbase) assert after_balance == 1000004999999999999987655L
def test_running_node_and_mining(project_test04, open_port): data_dir = get_geth_data_dir(project_test04, 'default') command, proc = run_geth_node(data_dir, rpc_port=open_port, mine=True) wait_for_popen(proc) rpc_client = Client('127.0.0.1', port=open_port) block_num = rpc_client.get_block_number() start = time.time() rpc_client.wait_for_block(block_num + 1, 60) assert block_num < rpc_client.get_block_number() proc.send_signal(signal.SIGINT) wait_for_popen(proc)
def test_running_node_and_mining(project_test04, open_port): data_dir = get_geth_data_dir(project_test04, 'default') command, proc = run_geth_node(data_dir, rpc_port=open_port, mine=True) time.sleep(2) rpc_client = Client('127.0.0.1', port=open_port) block_num = rpc_client.get_block_number() start = time.time() while time.time() < start + 10: time.sleep(0.2) if rpc_client.get_block_number() > block_num: break assert block_num < rpc_client.get_block_number() proc.send_signal(signal.SIGINT) wait_for_popen(proc)
def test_running_node_and_mining(project_test04, open_port): data_dir = get_geth_data_dir(project_test04, 'default') command, proc = run_geth_node(data_dir, rpc_port=open_port, mine=True) wait_for_popen(proc) rpc_client = Client('127.0.0.1', port=open_port) block_num = rpc_client.get_block_number() start = time.time() while rpc_client.get_block_number() <= block_num: time.sleep(0.2) if time.time() > start + 20: raise Exception('Could not mine block within 20 seconds') assert block_num < rpc_client.get_block_number() proc.send_signal(signal.SIGINT) wait_for_popen(proc)
def test_contract_creation(rpc_server, eth_coinbase): client = Client('127.0.0.1', '8545') data = "0x60606040525b5b600a8060136000396000f30060606040526008565b00" txn_hash = client.send_transaction( _from=eth_coinbase, value=12345, data=data, ) txn_receipt = client.get_transaction_receipt(txn_hash) contract_addr = txn_receipt['contractAddress'] contract_balance = client.get_balance(contract_addr) assert contract_balance == 12345
def test_get_transaction_by_hash(rpc_server, eth_coinbase): client = Client('127.0.0.1', '8545') to_addr = tester.encode_hex(tester.accounts[1]) txn_hash = client.send_transaction( _from=eth_coinbase, to=to_addr, value=12345, ) txn = client.get_transaction_by_hash(txn_hash) assert txn['from'].endswith(eth_coinbase) assert txn['to'].endswith(to_addr) assert int(txn['value'], 16) == 12345
def deploy(): """ Deploy contracts. """ contracts = utils.load_contracts(os.getcwd()) client = Client('127.0.0.1', '8545') deployed_contracts = utils.deploy_contracts(client, contracts) name_padding = max(len(n) + 1 for n in deployed_contracts.keys()) for name, info in deployed_contracts.items(): click.echo("{name} @ {addr} via txn:{txn_hash}".format( name=name.ljust(name_padding), addr=(info.get('addr') or '<pending>').ljust(42), txn_hash=info['txn'].ljust(66), ))
def test_get_code(rpc_server, eth_coinbase): client = Client('127.0.0.1', '8545') data = "0x606060405260f8806100126000396000f30060606040526000357c01000000000000000000000000000000000000000000000000000000009004806316216f3914604b578063a5f3c23b14606a578063dcf537b1146095576049565b005b605460045060e6565b6040518082815260200191505060405180910390f35b607f60048035906020018035906020015060ba565b6040518082815260200191505060405180910390f35b60a460048035906020015060d0565b6040518082815260200191505060405180910390f35b60008183019050805080905060ca565b92915050565b6000600782029050805080905060e1565b919050565b6000600d9050805080905060f5565b9056" txn_hash = client.send_transaction( _from=eth_coinbase, data=data, ) txn_receipt = client.get_transaction_receipt(txn_hash) contract_addr = txn_receipt['contractAddress'] code = client.get_code(contract_addr) # TODO: figure out what's going on here and why the two are almost the same # but not exactly the same. assert len(code) > 100 assert data.endswith(code[2:])
def deploy_client(request, populus_config): client_type = populus_config.get_value(request, 'deploy_client_type') if client_type == 'ethtester': from populus.ethtester_client import EthTesterClient client = EthTesterClient() elif client_type == 'rpc': from eth_rpc_client import Client rpc_host = populus_config.get_value(request, 'deploy_client_rpc_host') rpc_port = populus_config.get_value(request, 'deploy_client_rpc_port') client = Client(rpc_host, rpc_port) else: raise ValueError( "Unsupported client type '{0}'. Supported values are 'tester' and " "'rpc'") return client
sys.path += ['.', '..', 'tools', '../populus'] from overlog import ovlg, ovlocal import overlog import contract as mycon from populus import contracts as pocon from eth_rpc_client import Client overlog.SELECTED_GROUPS = ['overlog'] class Dummy(object): pass eth = Client(*mycon.RpcHost) ci = mycon.MainStore.last_ci_named(mycon.ConName) co_cls = pocon.Contract(eth, ci.name, { 'info': { 'abiDefinition': ci.abi, 'source': '' }, 'code': ci.code }) # contract obj cobj = co_cls(ci.addr) eth.accounts = eth.get_accounts() eth.defaults['from'] = eth.accounts[0]
from eth_alarm_client import ( BlockSage, PoolManager, Scheduler, ) alarm_addresses = ( ('0.1.0', '0xb0059e72ae1802fa1e1add5e7d0cb0eec1cc0cc1'), ('0.2.0', '0xc1cfa6ac1d7cf99bd1e145dcd04ec462b3b0c4da'), ('0.3.0', '0xdb15058402c241b04a03846f6fb104b1fbeea10b'), ('0.4.0 (latest)', '0x07307d0b136a79bac718f43388aed706389c4588'), ) DEFAULT_ADDRESS = '0x07307d0b136a79bac718f43388aed706389c4588' rpc_client = Client('127.0.0.1', '8545') def get_contract(contract_name): with open(os.path.join(os.path.dirname(__file__), 'alarm.json')) as contract_json: contracts = json.loads(contract_json.read()) return Contract(contracts[contract_name], contract_name) @click.group() def main(): pass @main.command()
def rpc_client(request, populus_config): from eth_rpc_client import Client rpc_port = populus_config.get_value(request, 'rpc_client_port') rpc_hostname = populus_config.get_value(request, 'rpc_client_host') client = Client(rpc_hostname, rpc_port) return client
def __init__(self, rpc_port): self.rpc_ip = '127.0.0.1' self.rpc_port = rpc_port self.rpc_eth = Client(self.rpc_ip, self.rpc_port)
def test_get_coinbase(rpc_server): client = Client('127.0.0.1', '8545') cb = client.get_coinbase() assert cb == '0x82a978b3f5962a5b0957d9ee9eef472ee55b42f1'
def test_get_balance(rpc_server, eth_coinbase): client = Client('127.0.0.1', '8545') balance = client.get_balance(eth_coinbase) assert balance == 1000000000000000000000000L
def rpc_client(): from eth_rpc_client import Client client = Client('127.0.0.1', '8545') return client
def deploy(dry_run, dry_run_chain_name, production, confirm, record, contracts_to_deploy): """ Deploys the specified contracts via the RPC client. """ if dry_run is None: # If we are doing a production deploy and dry_run was not specified, # then default to True dry_run = production client = Client("127.0.0.1", "8545") project_dir = os.getcwd() deploy_gas = None contracts = package_contracts(utils.load_contracts(project_dir)) if dry_run: dry_run_data_dir = get_geth_data_dir(project_dir, dry_run_chain_name) logfile_path = get_geth_logfile_path( dry_run_data_dir, logfile_name_fmt="deploy-dry-run-{0}.log", ) ensure_account_exists(dry_run_data_dir) _, dry_run_proc = run_geth_node(dry_run_data_dir, logfile=logfile_path) wait_for_geth_to_start(dry_run_proc) message = ("======= Executing Dry Run Deploy ========\n" "Chain Name : {chain_name}\n" "Data Directory : {data_dir}\n" "Geth Logfile : {logfile_path}\n\n" "... (deploying)\n").format( chain_name=dry_run_chain_name, data_dir=dry_run_data_dir, logfile_path=logfile_path, ) click.echo(message) # Dry run deploy uses max_gas dry_run_contracts = deploy_contracts( deploy_client=client, contracts=contracts, deploy_at_block=1, max_wait_for_deploy=60, from_address=None, max_wait=60, contracts_to_deploy=contracts_to_deploy, dependencies=None, constructor_args=None, deploy_gas=None, ) validate_deployed_contracts(client, dry_run_contracts) echo_post_deploy_message(client, dry_run_contracts) dry_run_proc.send_signal(signal.SIGINT) # Give the subprocess a SIGINT and give it a few seconds to # cleanup. utils.wait_for_popen(dry_run_proc) def get_deploy_gas(contract_name, contract_class): max_gas = int(client.get_max_gas() * 0.98) receipt = dry_run_contracts._deploy_receipts.get(contract_name) if receipt is None: return max_gas gas_used = int(receipt['gasUsed'], 16) return min(max_gas, int(gas_used * 1.1)) deploy_gas = get_deploy_gas contracts = package_contracts(utils.load_contracts(project_dir)) if not production: data_dir = get_geth_data_dir(project_dir, "default") logfile_path = get_geth_logfile_path( data_dir, logfile_name_fmt="deploy-dry-run-{0}.log", ) ensure_account_exists(data_dir) _, deploy_proc = run_geth_node(data_dir, logfile=logfile_path) wait_for_geth_to_start(deploy_proc) elif confirm: message = ( "You are about to deploy contracts to a production environment. " "You must have an RPC server that is unlocked running for this to " "work.\n\n" "Would you like to proceed?") if not click.confirm(message): raise click.Abort() if not dry_run: message = ( "You are about to do a production deploy with no dry run. Without " "a dry run, it isn't feasible to know gas costs and thus deployment " "may fail due to long transaction times.\n\n" "Are you sure you would like to proceed?") if confirm and not click.confirm(message): raise click.Abort() message = ("========== Executing Deploy ===========\n" "... (deploying)\n" "Chain Name : {chain_name}\n" "Data Directory : {data_dir}\n" "Geth Logfile : {logfile_path}\n\n" "... (deploying)\n").format( chain_name="production" if production else "default", data_dir="N/A" if production else data_dir, logfile_path="N/A" if production else logfile_path, ) click.echo(message) deployed_contracts = deploy_contracts( deploy_client=client, contracts=contracts, deploy_at_block=1, max_wait_for_deploy=120, from_address=None, max_wait=120, contracts_to_deploy=contracts_to_deploy, dependencies=None, constructor_args=None, deploy_gas=deploy_gas, ) validate_deployed_contracts(client, deployed_contracts) echo_post_deploy_message(client, deployed_contracts) if not production: if record: add_to_known_contracts(deployed_contracts, data_dir) deploy_proc.send_signal(signal.SIGINT) # Give the subprocess a SIGINT and give it a few seconds to # cleanup. utils.wait_for_popen(deploy_proc)
def attach(active): """ Enter a python shell with contracts and blockchain client available. """ project_dir = os.path.abspath(os.getcwd()) contracts_meta = utils.load_contracts(project_dir) client = Client('127.0.0.1', '8545') context = { 'contracts': package_contracts(contracts_meta), 'client': client, } data_dir = None if active: data_dir = get_active_data_dir(project_dir) if os.path.islink(data_dir): setup_known_instances(context, data_dir) else: click.echo( click.style("No Valid Active Chain Data Directory Found!", fg="red")) def redeploy(contracts=[], record=True): return (deploy_set(context, client, project_dir, data_dir=data_dir, record=record, contracts_by_name=contracts)) context["redeploy"] = redeploy contract_names = ', '.join(sorted(contracts_meta.keys())) banner = textwrap.dedent(""" Python: {python_version} Populus: v{populus_version} Project Path: {project_dir} contracts -> Contract classes client -> Blockchain client ({client_type}) redeploy -> Method to re-deploy project contracts Example: deployed_cts = redeploy() deployed_cts = redeploy(record = False) deployed_cts = redeploy(contracts = ["Example"]) Contracts: {contracts} Check contracts.<type>.known for deployed contracts. """).format( python_version=sys.version.partition('\n')[0], populus_version=populus.__version__, project_dir=project_dir, client_type="json-rpc", contracts=click.wrap_text( contract_names, initial_indent='', subsequent_indent=' ' * 4, ), ).strip() if is_ipython: shell = InteractiveConsole(user_ns=context) else: shell = InteractiveConsole(context) # Start the active directory link observer event_handler = ActiveDataDirChangedEventHandler( project_dir=project_dir, context=context, ) observer = get_active_dir_observer(project_dir, event_handler) observer.start() shell.interact(banner) observer.stop() observer.join()
def repeat_all_messages(message): # Название функции не играет никакой роли, важно не повторяться client = Client(host="ubuntu.athex.ru", port="8545") bot.send_message(message.chat.id, client.get_balance(client.get_coinbase()))