def get_compiled_registrar_contract(): if is_solc_03x(): compiled_contracts = compile_files([REGISTRAR_V3_SOURCE_PATH]) elif is_solc_04x(): compiled_contracts = compile_files([REGISTRAR_V4_SOURCE_PATH]) else: raise ValueError( "Unsupported version of solc. Found: {0}. Only 0.3.x and 0.4.x " "are supported".format(get_solc_version()) ) contract_data = compiled_contracts['Registrar'] return contract_data
def compile_project_contracts(project_dir, contracts_dir, **compiler_kwargs): compiler_kwargs.setdefault('output_values', ['bin', 'bin-runtime', 'abi']) contract_source_paths = find_project_contracts(project_dir, contracts_dir) try: compiled_sources = compile_files(contract_source_paths, **compiler_kwargs) except ContractsNotFound: return contract_source_paths, {} return contract_source_paths, compiled_sources
def validate_solc(): if get_solc_version() is None: raise RuntimeError( "Couldn't find the solc in the current $PATH.\n" "Make sure the solidity compiler is installed and available on your $PATH.", ) try: compile_files( [CONTRACT_MANAGER.get_contract_path(CONTRACT_HUMAN_STANDARD_TOKEN)], 'HumanStandardToken', optimize=False, ) except subprocess.CalledProcessError as e: msg = ( 'The solidity compiler failed to execute. Please make sure that you\n' 'are using the binary version of the compiler (solc-js is not compatible)\n' 'and that the version is >= {}'.format(MIN_REQUIRED_SOLC) ) if e.output: msg += ( '\n' 'Output: ' + e.output ) raise RuntimeError(msg) except OSError as e: msg = ( 'The solidity compiler failed to execute. Please make sure the\n' 'binary is compatible with your architecture and you can execute it.' ) child_traceback = getattr(e, 'child_traceback', None) if child_traceback: msg += ( '\n' 'Traceback: ' + child_traceback ) raise RuntimeError(msg)
def main(ethereum_net_addr): w3 = Web3(Web3.HTTPProvider(ethereum_net_addr)) w3.eth.defaultAccount = w3.eth.accounts[0] print("=== Experiment 2: Voting on Private Ethereum Network ===") # Compile the Solidity print("Compiling 'voting.sol' ...") compiled_sol = compile_files(['voting.sol']) contract_interface = compiled_sol['voting.sol:Voting'] # Get contract object voting_contract = w3.eth.contract(abi=contract_interface['abi'], bytecode=contract_interface['bin']) # Deploy the contract and get the address print("Deploying contract to network ...") tx_hash = voting_contract.constructor( [bytes('Alex', 'utf-8'), bytes('John', 'utf-8')]).transact() tx_receipt = w3.eth.waitForTransactionReceipt(tx_hash) print("Deployed voting contract: {}".format(tx_receipt.contractAddress)) # Get contract instance voting = w3.eth.contract( address=tx_receipt.contractAddress, abi=contract_interface['abi'], ) bytes_john = bytes('John', 'utf-8') bytes_alex = bytes('Alex', 'utf-8') print("Voting for 'John' ...") tx_hash = voting.functions.voteForCandidate(bytes_john).transact() w3.eth.waitForTransactionReceipt(tx_hash) print("Voting for 'John' ...") tx_hash = voting.functions.voteForCandidate(bytes_john).transact() w3.eth.waitForTransactionReceipt(tx_hash) print("Voting for 'Alex' ...") tx_hash = voting.functions.voteForCandidate(bytes_alex).transact() w3.eth.waitForTransactionReceipt(tx_hash) print("Voting for 'John' ...") tx_hash = voting.functions.voteForCandidate(bytes_john).transact() w3.eth.waitForTransactionReceipt(tx_hash) print("Total votes for 'John': {}".format( voting.functions.totalVotesFor(bytes_john).call())) print("Total votes for 'Alex': {}".format( voting.functions.totalVotesFor(bytes_alex).call()))
def compiler_contract(self,contract_file_name, contract_name,contract_args=None,import_remappings=[]): ''' 编译合约 ''' compiled_sol = compile_files([contract_file_name],import_remappings=import_remappings) contract_interface = compiled_sol.get("{}:{}".format(contract_file_name, contract_name)) bytecode = contract_interface['bin'] if contract_args: args_abi = self.constructor_abi(contract_args[0],contract_args[1]) if args_abi: bytecode += args_abi return bytecode
def compile(tree_depth): miximus = "../contracts/roll_up.sol" Pairing = "../contracts/Pairing.sol" Verifier = "../contracts/Verifier.sol" compiled_sol = compile_files([Pairing, Verifier, miximus], allow_paths="./contracts") miximus_interface = compiled_sol[miximus + ':roll_up'] verifier_interface = compiled_sol[Verifier + ':Verifier'] return (miximus_interface, verifier_interface)
def compile(tree_depth): miximus = "../contracts/Miximus.sol" MerkelTree = "../contracts/MerkelTree.sol" Pairing = "../contracts/Pairing.sol" Verifier = "../contracts/Verifier.sol" compiled_sol = compile_files([Pairing, MerkelTree, Pairing, Verifier, miximus], allow_paths="./contracts") miximus_interface = compiled_sol[miximus + ':Miximus'] verifier_interface = compiled_sol[Verifier + ':Verifier'] return(miximus_interface, verifier_interface)
def compile_contract(self, contract_name: str, libs=None, *args): """Compile contract and return JSON containing abi and bytecode""" contract_json = compile_files( [self.get_contract_path(contract_name)[0]], output_values=('abi', 'bin', 'ast'), import_remappings=self.get_mappings(), optimize=False) contract_json = { os.path.basename(key).split('.', 1)[0]: value for key, value in contract_json.items() } return contract_json.get(contract_name, None)
def get_static_or_compile( contract_path: str, contract_name: str, **compiler_flags): """Search the path of `contract_path` for a file with the same name and the extension `.static-abi.json`. If the file exists, and the recorded checksum matches, this will return the precompiled contract, otherwise it will compile it. Writing compiled contracts to the desired file and path happens only when the environment variable `STORE_PRECOMPILED` is set (to whatever value). Users are not expected to ever set this value, the functionality is exposed through the `setup.py compile_contracts` command. Args: contract_path: the path of the contract file contract_name: the contract name **compiler_flags: flags that will be passed to the compiler """ # this will be set by `setup.py compile_contracts` store_updated = os.environ.get('STORE_PRECOMPILED', False) precompiled = None precompiled_path = '{}.static-abi.json'.format(contract_path) try: with open(precompiled_path) as f: precompiled = json.load(f) except IOError: pass if precompiled or store_updated: checksum = contract_checksum(contract_path) if precompiled and precompiled['checksum'] == checksum: return precompiled validate_solc() compiled = compile_files( [contract_path], contract_name, **compiler_flags ) if store_updated: compiled['checksum'] = checksum with open(precompiled_path, 'w') as f: json.dump(compiled, f) print("'{}' written".format(precompiled_path)) compiled_abi = [ v for k, v in compiled.items() if k.split(':')[1] == contract_name ] assert len(compiled_abi) == 1 return compiled_abi[0]
def _compile_all_contracts(self) -> None: """ Compile solidity contracts into ABI and BIN. This requires solc somewhere in the $PATH and also the :ref:`ethereum.tools` python library. """ if self.contracts_source_dirs is None: raise TypeError( "Missing contracts source path, can't compile contracts.") # Raise an error if solc version goes down. self.compare_old_solc_version() old_working_dir = Path.cwd() chdir(_BASE) def relativise(path): return path.relative_to(_BASE) import_dir_map = [ '%s=%s' % (k, relativise(v)) for k, v in self.contracts_source_dirs.items() ] try: for contracts_dir in self.contracts_source_dirs.values(): res = compile_files( [ str(relativise(file)) for file in contracts_dir.glob('*.sol') ], output_values=('abi', 'bin', 'bin-runtime', 'ast', 'metadata'), import_remappings=import_dir_map, optimize=False, ) # Strip `ast` part from result # TODO: Remove after https://github.com/ethereum/py-solc/issues/56 is fixed res = { contract_name: { content_key: content_value for content_key, content_value in contract_content.items() if content_key != 'ast' } for contract_name, contract_content in res.items() } self.contracts.update(_fix_contract_key_names(res)) except FileNotFoundError as ex: raise ContractManagerCompilationError( 'Could not compile the contract. Check that solc is available.', ) from ex finally: chdir(old_working_dir)
def deploy_new_company(company_id): """ Deploy new company contract :param company_id: Company off chain id for deploy :return: True in case of successful, false otherwise """ try: instance = Company.objects.get(pk=company_id) except Company.DoesNotExist: logger.error( 'Company with id {} not found, contract will bot be deployed.'. format(company_id)) return False else: oracle = OracleHandler() w3 = utils.get_w3() contract_file = 'dapp/contracts/Company.sol' compile_sol = compile_files([ contract_file, ], output_values=( "abi", "ast", "bin", "bin-runtime", )) create_abi(compile_sol[contract_file + ':Company']['abi'], 'Company') obj = w3.eth.contract( abi=compile_sol[contract_file + ':Company']['abi'], bytecode=compile_sol[contract_file + ':Company']['bin'], bytecode_runtime=compile_sol[contract_file + ':Company']['bin-runtime'], ) args = [ settings.VERA_COIN_CONTRACT_ADDRESS, settings.VERA_ORACLE_CONTRACT_ADDRESS, ] logger.info('Try to unlock account: {}.'.format( oracle.unlockAccount())) try: txn_hash = obj.deploy(transaction={'from': oracle.account}, args=args) except Exception as e: logger.warning( 'Error while deploy new company contract. Company {}: {}'. format(company_id, e)) else: logger.info('Lock account: {}'.format(oracle.lockAccount())) save_txn.delay(txn_hash.hex(), 'NewCompany', instance.created_by.id, company_id) save_txn_to_history.delay(instance.created_by.id, txn_hash.hex(), 'Creation of a new Company contract')
def _compile_solidity_file(cls): logger.info("Compiling solidity code from solidity file of " + cls.__name__) if not cls._contract_name: cls._contract_name = cls.__class__.__name__ file_path = os.path.join(os.getcwd(), cls._solidity_file) # Windows dev uncomment below line # file_path = cls._solidity_file compiled_solidity = compile_files([file_path]) cls._abi_code = compiled_solidity[file_path + ":" + cls._contract_name]["abi"] cls._byte_code = compiled_solidity[file_path + ":" + cls._contract_name]["bin"]
def compile_file(): output = compile_files(["../rnode.sol"]) abi = output['../rnode.sol:Rnode']["abi"] bin = output['../rnode.sol:Rnode']["bin"] print(abi) print(bin) config = {} config["abi"] = abi config["bin"] = bin print("config: ") print(config) return config
def get_compiled_registrar_contract(): if is_solc_03x(): registrar_source_path = REGISTRAR_V3_SOURCE_PATH elif is_solc_04x(): registrar_source_path = REGISTRAR_V4_SOURCE_PATH else: raise ValueError( "Unsupported version of solc. Found: {0}. Only 0.3.x and 0.4.x " "are supported".format(get_solc_version())) compiled_contracts = compile_files([registrar_source_path]) contract_data = compiled_contracts['Registrar'] normalized_data = normalize_contract_data(contract_data, {}) return normalized_data
def __init__(self): """ Sets up Ethereum interaction variables and compiles the contract, allowing web3 to call functions directly. """ with open('./.blkchnmsg/contract', 'r') as f: self.addr = f.readline().strip() self.addr_2 = f.readline() compiled = compile_files( ['./../contract/contracts/BlckChnMsgStorage.sol']) compiled_manager = compile_files( ["./../contract/contracts/IdentityManager.sol"]) self.contract_interface = compiled[ './../contract/contracts/BlckChnMsgStorage.sol:BlckChnMsgStorage'] self.manager_interface = compiled_manager[ "./../contract/contracts/IdentityManager.sol:IdentityManager"] self.w3 = Web3(HTTPProvider("http://localhost:7545")) self.contract = self.w3.eth.contract( abi=self.contract_interface['abi'], bytecode=self.contract_interface['bin']) self.manager_contract = self.w3.eth.contract( abi=self.manager_interface['abi'], bytecode=self.manager_interface['bin'])
def init_singletons(): compiled_sol = compile_files(['review.sol']) contract_interface = compiled_sol['review.sol:Reviews'] w3 = web3.Web3(web3.providers.eth_tester.EthereumTesterProvider() ) # TODO: somehow configure private chain & geth w3.eth.enable_unaudited_features() contract = w3.eth.contract(abi=contract_interface['abi'], bytecode=contract_interface['bin']) return w3, contract, contract_interface
def deploy_contract(w3, contract_name, account, args=None): contract_compiled = compile_files([ CONTRACT_DIR + contract_name + '.sol' ])[CONTRACT_DIR + contract_name + '.sol:' + contract_name] contract = w3.eth.contract(abi=contract_compiled['abi'], bytecode=contract_compiled['bin']) tx_hash = contract.deploy(args=args, transaction={'from': account}) tx_receipt = wait_for_transaction_receipt(w3, tx_hash) contract_address = tx_receipt['contractAddress'] return contract_address
def compile(self): """ return: (abi, bytecode) """ compiled_sol = compile_files([ContractPath]) contract_interface = compiled_sol['{}:{}'.format( ContractPath, ContractName)] contract_interface = compiled_sol['<stdin>:Greeter'] self._abi = contract_interface['abi'] self._bytecode = contract_interface['bin'] return self.abi, self.bytecode
def validate_solc(): if get_solc_version() is None: raise RuntimeError( "Couldn't find the solc in the current $PATH.\n" "Make sure the solidity compiler is installed and available on your $PATH.", ) try: compile_files( [ CONTRACT_MANAGER.get_contract_path( CONTRACT_HUMAN_STANDARD_TOKEN) ], 'HumanStandardToken', optimize=False, ) except subprocess.CalledProcessError as e: msg = ( 'The solidity compiler failed to execute. Please make sure that you\n' 'are using the binary version of the compiler (solc-js is not compatible)\n' 'and that the version is >= {}'.format(MIN_REQUIRED_SOLC)) if e.output: msg += ('\n' 'Output: ' + e.output) raise RuntimeError(msg) except OSError as e: msg = ( 'The solidity compiler failed to execute. Please make sure the\n' 'binary is compatible with your architecture and you can execute it.' ) child_traceback = getattr(e, 'child_traceback', None) if child_traceback: msg += ('\n' 'Traceback: ' + child_traceback) raise RuntimeError(msg)
def compile_drfp_sol(): CONTRACT_NAME = 'drfp' FILE_NAME = CONTRACT_NAME + '.sol' PATH = '/truffle/contracts/' + FILE_NAME printd('compiling %s...' % (FILE_NAME)) COMPILED = compile_files([FILE_NAME]) RFP = COMPILED[FILE_NAME + ':' + CONTRACT_NAME] global DRFPContract DRFPContract = testrpc.eth.contract(abi=RFP['abi'], bytecode=RFP['bin'], bytecode_runtime=RFP['bin-runtime']) printd(DRFPContract)
def __init__(self, contract_file_name, contract_name): compiled_sol = compile_files([contract_file_name]) contract_interface = compiled_sol['{}:{}'.format( contract_file_name, contract_name)] contract = w3.eth.contract( abi=contract_interface['abi'], bytecode=contract_interface['bin'], bytecode_runtime=contract_interface['bin-runtime']) tx_hash = contract.deploy(transaction={'from': w3.eth.accounts[0]}) self.mining(2) tx_recepit = w3.eth.getTransactionReceipt(tx_hash) contract_address = tx_recepit['contractAddress'] self.contract_instance = contract(contract_address)
def deploy_n_transact(file_path, mappings=[]): # compile all files contracts = compile_files(file_path, import_remappings=mappings) link_add = {} contract_interface, links = separate_main_n_link(file_path, contracts) # first deploy all link libraries for link in links: link_add[link] = deploy_contract(links[link]) # now link dependent library code to main contract binary # https://solidity.readthedocs.io/en/v0.4.24/using-the-compiler.html?highlight=library if link_add: contract_interface['bin'] = link_code(contract_interface['bin'], link_add) # return contract receipt and abi(application binary interface) return deploy_contract(contract_interface), contract_interface['abi']
def _compile_all_contracts(self) -> Dict: """ Compile solidity contracts into ABI and BIN. This requires solc somewhere in the $PATH and also the :ref:`ethereum.tools` python library. The return value is a dict that should be written into contracts.json. """ ret = {} old_working_dir = Path.cwd() chdir(_BASE) def relativise(path: Path) -> Path: return path.relative_to(_BASE) import_dir_map = [ "%s=%s" % (k, relativise(v)) for k, v in self.contracts_source_dirs.items() ] import_dir_map.insert( 0, ".=.") # allow solc to compile contracts in all subdirs try: for contracts_dir in self.contracts_source_dirs.values(): res = compile_files( [ str(relativise(file)) for file in contracts_dir.glob("*.sol") ], output_values=PRECOMPILED_DATA_FIELDS + ["ast"], import_remappings=import_dir_map, optimize=False, ) # Strip `ast` part from result # TODO: Remove after https://github.com/ethereum/py-solc/issues/56 is fixed res = { contract_name: { content_key: content_value for content_key, content_value in contract_content.items() if content_key != "ast" } for contract_name, contract_content in res.items() } ret.update(_fix_contract_key_names(res)) except FileNotFoundError as ex: raise ContractSourceManagerCompilationError( "Could not compile the contract. Check that solc is available." ) from ex finally: chdir(old_working_dir) check_runtime_codesize(ret) return ret
def compile_project_contracts(project, compiler_settings=None): logger = logging.getLogger('populus.compilation.compile_project_contracts') if compiler_settings is None: compiler_settings = {} compiler_settings.setdefault('output_values', DEFAULT_COMPILER_OUTPUT_VALUES) logger.debug("Compiler Settings: %s", pprint.pformat(compiler_settings)) project_contract_source_paths = get_project_source_paths( project.contracts_source_dir) logger.debug( "Found %s project source files: %s", len(project_contract_source_paths), project_contract_source_paths, ) test_contract_source_paths = get_test_source_paths(project.tests_dir) logger.debug( "Found %s test source files: %s", len(test_contract_source_paths), test_contract_source_paths, ) all_source_paths = tuple( itertools.chain( project_contract_source_paths, test_contract_source_paths, )) try: compiled_contracts = compile_files(all_source_paths, **compiler_settings) except ContractsNotFound: return all_source_paths, {} normalized_compiled_contracts = dict( process_compiler_output(contract_name, contract_data) for contract_name, contract_data in compiled_contracts.items()) logger.info("> Found %s contract source files", len(all_source_paths)) for path in all_source_paths: logger.info(" - %s", os.path.relpath(path)) logger.info("> Compiled %s contracts", len(normalized_compiled_contracts)) for contract_name in sorted(normalized_compiled_contracts.keys()): logger.info(" - %s", contract_name) return all_source_paths, normalized_compiled_contracts
def test_contract_factories(web3): from solc import compile_files from populus.utils.filesystem import recursive_find_files from populus.utils.contracts import ( package_contracts, construct_contract_factories, ) base_tests_dir = os.path.dirname(__file__) solidity_source_files = recursive_find_files(base_tests_dir, '*.sol') compiled_contracts = compile_files(solidity_source_files) test_contract_factories = construct_contract_factories(web3, compiled_contracts) return package_contracts(test_contract_factories)
def main(): if len(sys.argv) != 2: sys.stderr.write("usage: " + sys.argv[0] + " dirpath\n") sys.stderr.write("dirpath - path with solidity files") sys.stderr.write("every solidity file should endswith with .sol") exit(1) folder_path = sys.argv[1] create_folder(folder_path + "/bin") for file_name in os.listdir(folder_path): if ".sol" not in file_name: continue log("\n\n\nCompiling file: " + file_name) file_path = folder_path + '/' + file_name file_solc_version, _, contract_name, _ = file_name.split("--") if file_solc_version is None or contract_name is None: sys.stderr.write("Bad file name: " + file_name) exit(2) bin_file_path = "{}/bin/{}--.bin".format(folder_path, file_name[:-6]) if os.path.exists(bin_file_path): # Skip if file is compiled log("Skipping. File compiled: " + bin_file_path) continue if file_solc_version not in COMPILER_BIN.keys(): sys.stderr.write("File has no supported compiler version: " + file_solc_version) exit(2) solc_path = COMPILER_BIN[file_solc_version] log("Compiler version: " + file_solc_version) log("File path: " + file_path) log("Set env SOLC_BINARY path to: " + solc_path) log("Contract name: " + contract_name) os.environ["SOLC_BINARY"] = solc_path bin_data = solc.compile_files([file_path], optimize=True)["{}:{}".format( file_path, contract_name)]["bin"] log("Saving bin to: " + bin_file_path) with open(bin_file_path, "w") as f: f.write(bin_data)
def regen_artifacts(contracts_directory, artifacts_file): starting_directory = os.getcwd() os.chdir(contracts_directory) # Search and load contract objects from filenames contracts = {} solc_files = [] for root, dirs, files in os.walk(os.getcwd()): for _file in files: if _file.endswith('.sol'): solc_files.append(os.path.join(root, _file)) continue # No need to process further # Vyper contracts are 1 contract per file, # and do not have an explicit name, # so use base of filename as name #if _file.endswith('.vy'): # name = _file.strip('.vy') # with open(os.path.join(root, _file), 'r') as f: # full_code = f.read() # contracts[name] = Contract(full_code, vyper.parser, vyper.compiler) # continue # No need to process further # Solidity can have multiple contracts in a file # and has no batching functionality, # so just create object for every contract if solc_files: # TODO solc needs to be located in the contracts_directory to work results = solc.compile_files(solc_files) for name, artifact in results.items(): # TODO Fix this so it works right with Contract object name = name.split(':')[1] contracts[name] = Contract(b"", lambda c: c, lambda c: artifact) artifact['checksum'] = generate_checksum(b"") contracts[name].read_artifacts(artifact) # Set artifacts from file (if present) if os.path.isfile(artifacts_file): with open(artifacts_file, 'r') as f: for name, artifacts in json.loads(f.read()).items(): if name in contracts.keys(): contracts[name].read_artifacts(artifacts) os.chdir(starting_directory) # Once everything is parsed, write it all out again artifact_list = [(name, contract.write_artifacts()) for name, contract in contracts.items()] with open(artifacts_file, 'w') as f: artifacts = dict(artifact_list) f.write(json.dumps(artifacts))
def test_contract_factories(web3): from solc import compile_files from populus.utils.filesystem import recursive_find_files from populus.utils.contracts import ( package_contracts, construct_contract_factories, ) base_tests_dir = os.path.dirname(__file__) solidity_source_files = recursive_find_files(base_tests_dir, '*.sol') compiled_contracts = compile_files(solidity_source_files) test_contract_factories = construct_contract_factories( web3, compiled_contracts) return package_contracts(test_contract_factories)
def __init__(self, contract_address, account=None, password=None): self.web3 = utils.get_w3() self.account = account or settings.WEB_ETH_COINBASE self.contract_address = contract_address try: with open(settings.ABI_PATH + 'Company.abi.json', 'r') as ad: self.abi = json.load(ad) except FileNotFoundError: path = 'dapp/contracts/Company.sol' compiled = compile_files([path, ], output_values=("abi", "ast", "bin", "bin-runtime",)) with open(settings.ABI_PATH + 'Company.abi.json', 'w+') as ad: ad.write(json.dumps(compiled[path + ':Company']['abi'])) self.abi = compiled[path + ':Company']['abi'] self.__password = password or settings.COINBASE_PASSWORD_SECRET self.contract = self.web3.eth.contract(abi=self.abi, address=self.contract_address)
def compile_contracts(contract_name: str, alias: str, paths: List[str]) -> str: ''' Compile multiple contracts to bytecode. ''' bin_id = '{0}.sol:{0}'.format(contract_name) contract_paths = [ "{dir}/{alias}{path}".format(dir=V2_PACKAGES, alias=alias, path=path[1:]) for path in paths ] compiled_source = compile_files(contract_paths) compiled_source_bin = compiled_source[ "{dir}/{alias}/contracts/{id}".format(dir=V2_PACKAGES, alias=alias, id=bin_id)]['bin'] return compiled_source_bin
def __init__(self, contract_address, account=None): self.web3 = Web3(HTTPProvider(settings.NODE_URL)) self.web3.middleware_stack.inject(geth_poa_middleware, layer=0) self.account = account or settings.WEB_ETH_COINBASE self.contract_address = contract_address self.__password = settings.COINBASE_PASSWORD_SECRET try: with open(settings.ABI_PATH + 'Candidate.abi.json', 'r') as ad: self.abi = json.load(ad) except FileNotFoundError: path = 'dapp/contracts/Candidate.sol' compiled = compile_files([path, ], output_values=("abi", "ast", "bin", "bin-runtime",)) with open(settings.ABI_PATH + 'Candidate.abi.json', 'w+') as ad: ad.write(json.dumps(compiled[path + ':Candidate']['abi'])) self.abi = compiled[path + ':Candidate']['abi'] self.contract = self.web3.eth.contract(abi=self.abi, address=self.contract_address)
def deploy_contract(): # get accounts accounts = web3.eth.accounts # contract stuff contract = compile_files(['./dragonstone.sol']).popitem()[1] abi = contract.get('abi') bytecode = contract.get('bin') web3_contract = web3.eth.contract(abi=abi, bytecode=bytecode) transaction = {'from': accounts[0], 'gas': 500000} trans_hash = web3_contract.deploy(transaction=transaction) txn_receipt = web3.eth.getTransactionReceipt(trans_hash) contract_address = txn_receipt['contractAddress'] instance = web3_contract.call({'to': contract_address}) i = instance.create(accounts[1], 1 * 10**18) print(web3.eth.getBalance(accounts[0])) print(web3.eth.getBalance(accounts[1]))
def compile(self) -> dict: """Executes the compiler with parameters specified in the json config""" source_paths = set() source_walker = os.walk(top=self._solidity_source_dir, topdown=True) if self._test_solidity_source_dir: test_source_walker = os.walk(top=self._test_solidity_source_dir, topdown=True) source_walker = itertools.chain(source_walker, test_source_walker) for root, dirs, files in source_walker: for filename in files: if filename.endswith('.sol'): source_paths.add(os.path.join(root, filename)) # Compile with remappings: https://github.com/ethereum/py-solc project_root = dirname(self._solidity_source_dir) remappings = ( "contracts={}".format(self._solidity_source_dir), "zeppelin={}".format(os.path.join(project_root, 'zeppelin')), "proxy={}".format(os.path.join(project_root, 'proxy')), ) try: compiled_sol = compile_files(source_files=source_paths, import_remappings=remappings, allow_paths=project_root, optimize=10) except FileNotFoundError: raise RuntimeError( "The solidity compiler is not at the specified path. " "Check that the file exists and is executable.") except PermissionError: raise RuntimeError( "The solidity compiler binary at {} is not executable. " "Check the file's permissions.".format(self.__sol_binary_path)) except SolcError: raise # Cleanup the compiled data keys interfaces = { name.split(':')[-1]: compiled_sol[name] for name in compiled_sol } return interfaces
def get_compiled_contract_data(self, source_file_paths, import_remappings): self.logger.debug("Compiler Settings: %s", pprint.pformat(self.compiler_settings)) try: compiled_contracts = compile_files(source_file_paths, **self.compiler_settings) except ContractsNotFound: return {} normalized_compiled_contracts = dict( ( _get_contract_name(name_from_compiler), _normalize_combined_json_contract_data(data_from_compiler), ) for name_from_compiler, data_from_compiler in compiled_contracts.items() ) return normalized_compiled_contracts
def test_contract_factories(project): from solc import compile_files from populus.utils.filesystem import ( recursive_find_files, ) from populus.compilation import ( find_project_contracts, ) base_tests_dir = os.path.dirname(__file__) test_source_files = [ os.path.relpath(source_path, project.project_dir) for source_path in recursive_find_files(base_tests_dir, 'Test*.sol') ] all_source_files = test_source_files + list(find_project_contracts( project.project_dir, project.contracts_dir, )) compiled_contracts = compile_files(all_source_files) for contract_name, contract_data in compiled_contracts.items(): project.compiled_contracts.setdefault(contract_name, contract_data)
def compile_files_cwd(*args, **kwargs): """change working directory to contract's dir in order to avoid symbol name conflicts""" # get root directory of the contracts compile_wd = os.path.commonprefix(args[0]) # edge case - compiling a single file if os.path.isfile(compile_wd): compile_wd = os.path.dirname(compile_wd) # remove prefix from the files if compile_wd[-1] is not '/': compile_wd += '/' file_list = [ x.replace(compile_wd, '') for x in args[0] ] cwd = os.getcwd() try: os.chdir(compile_wd) compiled_contracts = compile_files(file_list, **kwargs) finally: os.chdir(cwd) return compiled_contracts
def test_source_files_compilation(contracts_dir): SOURCE = "contract Foo { function Foo() {} function return13() returns (uint) { return 13; } }" source_file_path = os.path.join(contracts_dir, 'Foo.sol') with open(source_file_path, 'w') as source_file: source_file.write(SOURCE) output = compile_files([source_file_path]) assert output assert 'Foo' in output foo_contract_data = output['Foo'] assert 'code' in foo_contract_data assert 'code_runtime' in foo_contract_data assert 'source' in foo_contract_data assert 'meta' in foo_contract_data assert 'compilerVersion' in foo_contract_data['meta'] # TODO: figure out how to include source. assert foo_contract_data['source'] is None assert foo_contract_data['meta']['compilerVersion'] == get_solc_version()
def get_compiled_contracts(self, source_file_paths, import_remappings): self.logger.debug("Import remappings: %s", import_remappings) self.logger.debug("Compiler Settings: %s", pprint.pformat(self.compiler_settings)) if 'import_remappings' in self.compiler_settings and import_remappings is not None: self.logger.warn("Import remappings setting will be overridden by backend settings") try: compilation_result = compile_files( source_file_paths, import_remappings=import_remappings, **self.compiler_settings ) except ContractsNotFound: return {} compiled_contracts = pipe( compilation_result, normalize_compilation_result, post_process_compiled_contracts, ) return compiled_contracts
def test_compile_empty_folder(): """Execute compile on a folder without contracts.""" with pytest.raises(ContractsNotFound): compile_files([])