def compile_contract(bidding_time=10, reveal_time=15): global Auction # compile all contract files sol_contracts = compile_files([SOL_PATH]) contract = sol_contracts[SOL_PATH + ':' + CONTRACT_NAME] # separate main file and link file Auction = w3.eth.contract(abi=contract['abi'], bytecode=contract['bin']) # Get transaction hash from deployed contract w3.eth.default_account = w3.eth.accounts[0] tx_hash = Auction.constructor(bidding_time, reveal_time, SELLER_ADDRESS).transact( {'from': w3.eth.accounts[0]}) # Get tx receipt to get contract address tx_receipt = w3.eth.waitForTransactionReceipt(tx_hash) # print("hash ", tx_hash) # print("rec ", tx_receipt) print("contract ", tx_receipt['contractAddress']) return (Auction, tx_receipt['contractAddress'])
def compile_contract(): # compile all contract files sol_contracts = compile_files([SOL_PATH]) # print(sol_contracts) contract = sol_contracts[SOL_PATH + ':' + CONTRACT_NAME] # separate main file and link file Storage = w3.eth.contract( abi=contract['abi'], bytecode=contract['bin']) # print(contract) # print(w3.eth.accounts[1]) # Get transaction hash from deployed contract w3.eth.default_account = w3.eth.accounts[0] tx_hash = Storage.constructor().transact({'from':w3.eth.accounts[0]}) # Get tx receipt to get contract address tx_receipt = w3.eth.waitForTransactionReceipt(tx_hash) print("hash ", tx_hash) print("rec ", tx_receipt) return tx_receipt['contractAddress']
def compile_source_files(self): """Compiles 'contract_to_deploy' from specified contract. Loops through contracts in 'contract_directory' and creates a list of absolute paths to be passed to the py-solc-x's 'compile_files' method. Returns: self.all_compiled_contracts (dict): all the compiler outputs (abi, bin, ast...) for every contract in contract_directory """ deployment_list = [] for contract in os.listdir(self.contract_directory): deployment_list.append( os.path.join(self.contract_directory, contract)) self.all_compiled_contracts = compile_files(deployment_list) print("Compiled contract keys:\n{}".format('\n'.join( self.all_compiled_contracts.keys())))
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) # print (contract_interface) # first deploy all link libraries # here link is refers to the second contarct "stringUtils.sol" 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_contract(self): install_solc("v" + self.app_config.compiler_version) set_solc_version("v" + self.app_config.compiler_version) ''' Compiles smart contract, creates bytecode and abi ''' # loading contract file data with open(tools.get_contr_path(), "r") as source_file: source_raw = source_file.read() # loading configuration data with open(tools.get_compile_data_path()) as opt_file: raw_opt = opt_file.read() opt = json.loads(raw_opt) #opt["sources"]["ResearchCertificate.sol"]["content"] = source_raw #compiled_sol = compile_source(source_raw) compiled_sol = compile_files([tools.get_contr_path()], output_values=["abi", "bin"]) contract_interface = compiled_sol[tools.get_contr_path() + ":ResearchCertificate"] self.bytecode = contract_interface['bin'] self.abi = contract_interface['abi'] logging.info("Succesfully compiled contract")
def compiler(sol_file_name): with open('%s' % sol_file_name, 'r', encoding="utf-8") as sol_file: if_pragma = False while True: pragma_line = sol_file.readline() #print(pragma_line) pragma_pattern = r'(pragma)[\s]+(solidity)[\s]+(.+);[\s]*(/+.*)*' match_pragma_pattern = re.match(pragma_pattern, pragma_line) if match_pragma_pattern: pragmas = match_pragma_pattern.groups() pragma = pragmas[2] #print('pragma: %s' % pragma) install_solc_pragma(pragma) set_solc_version_pragma(pragma) if_pragma = True break if not pragma_line: break if not if_pragma: # no pragma install_solc('v0.4.25') set_solc_version('v0.4.25') compiled_sol = compile_files([sol_file_name]) file_name_key_list = list(compiled_sol.keys()) contract_name_list = list() for k in file_name_key_list: contract_name = k.split(':')[-1] contract_name_list.append(contract_name) with open('%s.bin.txt' % contract_name, 'w', encoding="utf-8") as outfile: json.dump(compiled_sol[k]['bin'], outfile, ensure_ascii=False) with open('%s.asm.json' % contract_name, 'w', encoding="utf-8") as outfile: json.dump(compiled_sol[k]['asm'], outfile, ensure_ascii=False) with open('ast.json', 'w', encoding="utf-8") as outfile: json.dump(compiled_sol[file_name_key_list[0]]['ast'], outfile, ensure_ascii=False) return (if_pragma, contract_name_list)
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. """ solcx.install.install_solc(SOLC_VERSION) solcx.set_solc_version(SOLC_VERSION) 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 = solcx.compile_files( [str(relativise(file)) for file in contracts_dir.glob("*.sol")], output_values=PRECOMPILED_DATA_FIELDS, import_remappings=import_dir_map, optimize=True, optimize_runs=200, ) 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_contracts( zksnark: IZKSnarkProvider) -> Tuple[Interface, Interface, Interface]: contracts_dir = get_contracts_dir() (proof_verifier_name, mixer_name) = zksnark.get_contract_names() otsig_verifier_name = constants.SCHNORR_VERIFIER_CONTRACT path_to_proof_verifier = os.path.join(contracts_dir, proof_verifier_name + ".sol") path_to_otsig_verifier = os.path.join(contracts_dir, otsig_verifier_name + ".sol") path_to_mixer = os.path.join(contracts_dir, mixer_name + ".sol") compiled_sol = compile_files( [path_to_proof_verifier, path_to_otsig_verifier, path_to_mixer]) proof_verifier_interface = \ compiled_sol[path_to_proof_verifier + ':' + proof_verifier_name] otsig_verifier_interface = \ compiled_sol[path_to_otsig_verifier + ':' + otsig_verifier_name] mixer_interface = compiled_sol[path_to_mixer + ':' + mixer_name] return (proof_verifier_interface, otsig_verifier_interface, mixer_interface)
def prepare_contracts(solidity_files): compiled = solcx.compile_files( solidity_files, optimize=True, allow_paths= "/Users/hkalodner/Documents/OffchainLabs/Github/arbitrum-python/contracts" ) contracts = {} for contractName in compiled: name = contractName.split(":")[-1] contract = compiled[contractName] address_bytes = hashlib.sha224( bytes.fromhex(contract['bin-runtime'][2:])).hexdigest()[:40] address_string = web3.Web3.toChecksumAddress(address_bytes) contracts[name] = { 'address': address_string, 'abi': contract['abi'], 'name': name, 'code': contract['bin'], } return contracts
def deploy_intervention_manager(): compiledInterventionManager = solcx.compile_files( [CONTRACT_SOURCES_FOLDER + CONTRACT_IM_SOURCES_FILENAME]) interventionManagerId, interventionManagerInterface = compiledInterventionManager.popitem( ) deployTransactionHash = tools.w3.eth.contract( abi=interventionManagerInterface['abi'], bytecode=interventionManagerInterface['bin']).constructor().transact() console( LOG_FLAG_INFO, "intervention manager contract transaction sent, waiting validation") interventionManagerDeployWaitingThread = threading.Thread( target=deploy_waiting, name="interventionManager", args=( deployTransactionHash, interventionManagerInterface['abi'], ), daemon=True) interventionManagerDeployWaitingThread.start()
def compile_source_files(self): """Compiles 'contract_to_deploy' from specified contract. Loops through contracts in 'contract_directory' and creates a list of absolute paths to be passed to the py-solc-x's 'compile_files' method. Returns: self.all_compiled_contracts (dict): all the compiler outputs (abi, bin, ast...) for every contract in contract_directory """ deployment_list = [] for root, directories, files in os.walk(self.contract_directory): for file in files: print('ADDED : ', os.path.abspath(os.path.join(root, file))) deployment_list.append( os.path.abspath(os.path.join(root, file))) kwargs = {'--allowed-paths': '*'} self.all_compiled_contracts = compile_files(deployment_list, **kwargs) print("Compiled contract keys:\n{}".format('\n'.join( self.all_compiled_contracts.keys())))
def get_contract_instance(contract_dict=None, source=None, contract_name=None, address=None, abi_file=None, bytecode_file=None): w3 = web3.Web3() contract = None if source and contract_name: output = solcx.compile_files([source]) if platform == "win32": source = os.path.abspath(source).replace("\\", "/") contract_dict = output[f"{source}:{contract_name}"] if "bin" in contract_dict: contract_dict["bytecode"] = contract_dict.pop("bin") elif "code" in contract_dict: contract_dict["bytecode"] = contract_dict.pop("code") if contract_dict: contract = w3.eth.contract(abi=contract_dict['abi'], bytecode=contract_dict['bytecode'], address=address) elif abi_file: with open(abi_file, 'r') as abi_file: abi = json.loads(abi_file.read()) if address: contract = w3.eth.contract(abi=abi, address=address) elif bytecode_file: bytecode = None if bytecode_file: with open(bytecode_file, 'r') as bytecode_file: bytecode = bytecode_file.read() contract = w3.eth.contract(abi=abi, bytecode=bytecode) else: raise ValueError( "The bytecode or the address must be provided") return contract
def generate_solidity_payload( file: str, version: Optional[str], contracts: List[str] = None, remappings: Tuple[str] = None, ) -> Dict: """Generate a MythX analysis request from a given Solidity file. This function will open the file, try to detect the used solc version from the pragma definition, and automatically compile it. If the given solc version is not installed on the client's system, it will be automatically downloaded. From the solc output, the following data is sent to the MythX API for analysis: * :code:`abi` * :code:`ast` * :code:`bin` * :code:`bin-runtime` * :code:`srcmap` * :code:`srcmap-runtime` :param file: The path pointing towards the Solidity file :param version: The solc version to use for compilation :param contracts: The contract name(s) to submit :param remappings: Import remappings to pass to solcx :return: The payload dictionary to be sent to MythX """ with open(file) as f: solc_version = re.findall(PRAGMA_PATTERN, f.read()) LOGGER.debug(f"solc version matches in {file}: {solc_version}") if not (solc_version or version): # no pragma found, user needs to specify the version raise click.exceptions.UsageError( "No pragma found - please specify a solc version with --solc-version" ) solc_version = f"v{version or solc_version[0]}" if solc_version not in solcx.get_installed_solc_versions(): try: LOGGER.debug(f"Installing solc {solc_version}") solcx.install_solc(solc_version) except Exception as e: raise click.exceptions.UsageError( f"Error installing solc version {solc_version}: {e}") solcx.set_solc_version(solc_version, silent=True) try: cwd = str(Path.cwd().absolute()) LOGGER.debug(f"Compiling {file} under allowed path {cwd}") result = solcx.compile_files( [file], output_values=( "abi", "ast", "bin", "bin-runtime", "srcmap", "srcmap-runtime", ), import_remappings=remappings or [ f"openzeppelin-solidity/={cwd}/node_modules/openzeppelin-solidity/", f"openzeppelin-zos/={cwd}/node_modules/openzeppelin-zos/", f"zos-lib/={cwd}/node_modules/zos-lib/", ], allow_paths=cwd, ) except solcx.exceptions.SolcError as e: raise click.exceptions.UsageError( f"Error compiling source with solc {solc_version}: {e}") # sanitize solcx keys new_result = {} for key, value in result.items(): new_key = key.split(":")[1] LOGGER.debug(f"Sanitizing solc key {key} -> {new_key}") new_result[new_key] = value result = new_result payload = {"sources": {}, "solc_version": solc_version} bytecode_max = 0 for contract_name, contract_data in result.items(): ast = contract_data["ast"] source_path = str(Path(ast.get("attributes", {}).get("absolutePath"))) creation_bytecode = contract_data["bin"] deployed_bytecode = contract_data["bin-runtime"] source_map = contract_data["srcmap"] deployed_source_map = contract_data["srcmap-runtime"] with open(source_path) as source_f: source = source_f.read() LOGGER.debug( f"Loaded contract source with {len(source)} characters") # always add source and AST, even if dependency payload["sources"][source_path] = {"source": source, "ast": ast} if (contracts and contract_name not in contracts) or ( not contracts and len(creation_bytecode) < bytecode_max): LOGGER.debug( f"Found dependency contract {contract_name} - continung") continue bytecode_max = len(creation_bytecode) LOGGER.debug(f"Updaing main payload for {contract_name}") payload.update({ "contract_name": contract_name, "main_source": source_path, "source_list": [source_path], "bytecode": patch_solc_bytecode(creation_bytecode), "source_map": zero_srcmap_indices(source_map), "deployed_source_map": zero_srcmap_indices(deployed_source_map), "deployed_bytecode": patch_solc_bytecode(deployed_bytecode), "solc_version": solc_version, }) return payload
import solcx # If you haven't already installed the Solidity compiler, uncomment the following line # solcx.install_solc() # Compile contract temp_file = solcx.compile_files('Incrementer.sol') # Export contract data abi = temp_file['Incrementer.sol:Incrementer']['abi'] bytecode = temp_file['Incrementer.sol:Incrementer']['bin']
import os from web3 import Web3 from solcx import compile_files dir_path = os.path.dirname(os.path.realpath(__file__)) greeter_path = os.path.join(dir_path, 'greeter.sol') # complie complied_greeter = compile_files([greeter_path]) greeter_key = greeter_path + ":Greeter" greeter_abi = complied_greeter[greeter_key]['abi'] greeter_bytecode = complied_greeter[greeter_key]['bin'] ganeche_url = "HTTP://127.0.0.1:7545" web3 = Web3(Web3.HTTPProvider(ganeche_url)) web3.eth.defaultAccount = web3.eth.accounts[0] # deploy contract Greeter = web3.eth.contract(abi=greeter_abi, bytecode=greeter_bytecode) tx_hash = Greeter.constructor().transact() tx_receipt = web3.eth.waitForTransactionReceipt(tx_hash) # interact contract greeter = web3.eth.contract(address=tx_receipt.contractAddress, abi=greeter_abi) print(greeter.functions.greet().call()) tx_hash = greeter.functions.setGreeting("안녕!").transact() tx_receipt = web3.eth.waitForTransactionReceipt(tx_hash) print(greeter.functions.greet().call())
def test_compile_multiple_files_fails_bad_path(baz_path): with pytest.raises(SolcError): solcx.compile_files([baz_path])
listOfCandidates = ['A', 'B', 'C'] hex_array = [ Web3.toHex(str.encode(bytes_data)) for bytes_data in listOfCandidates ] def deploy_contract(contract_interface): tx_hash = w3.eth.contract( abi=contract_interface['abi'], bytecode=contract_interface['bin']).constructor(hex_array).transact( {'from': w3.eth.accounts[1]}) address = w3.eth.getTransactionReceipt(tx_hash)['contractAddress'] return address # compile all contract files contracts = compile_files(['x.sol']) # separate main file and link file main_contract = contracts.pop("x.sol:Election") with open('data.json', 'w') as outfile: data = { "abi": main_contract['abi'], "contract_address": deploy_contract(main_contract) } json.dump(data, outfile, indent=4, sort_keys=True)
import sys sys.path.append('../../..') from solcx import compile_files from ammolite import (Cli, HTTPProvider, Account) from utils import wait_for_receipts # frontend = 'http://localhost:8080' # private_key = 'cfac4f5fa828072ba8313b0686f02f576fa0fc8caba947569429e88968577865' frontend = sys.argv[1] private_key = sys.argv[2] compiled_sol = compile_files( ['./contract/MainService.sol', './contract/ConcurrentLibInterface.sol'], output_values=['abi', 'bin']) storage_svc = compiled_sol['./contract/MainService.sol:StorageService'] computing_svc = compiled_sol['./contract/MainService.sol:ComputingService'] main_svc = compiled_sol['./contract/MainService.sol:MainService'] cli = Cli(HTTPProvider(frontend)) storage_svc_contract = cli.eth.contract(abi=storage_svc['abi'], bytecode=storage_svc['bin']) computing_svc_contract = cli.eth.contract(abi=computing_svc['abi'], bytecode=computing_svc['bin']) main_svc_contract = cli.eth.contract(abi=main_svc['abi'], bytecode=main_svc['bin']) account = Account(private_key) raw_tx, tx_hash = account.sign( storage_svc_contract.constructor().buildTransaction({
def test_compile_files_allow_empty(empty_path): assert solcx.compile_files([empty_path], allow_empty=True) == {}
def compileContracts(files): return compile_files(files)
sys.path.append('../../..') from solcx import compile_files from ammolite import (Cli, HTTPProvider, Account) from rich.console import Console sol_dir = sys.argv[1] frontend = sys.argv[2] owner_key = sys.argv[3] sols = [] for root, _, files in os.walk(sol_dir): for f in files: if f.endswith('.sol'): sols.append(os.path.join(root, f)) compiled_sols = compile_files(sols, output_values = ['abi', 'bin']) ds_token = compiled_sols[sol_dir + 'token.sol:DSToken'] cli = Cli(HTTPProvider(frontend)) ds_token_contract = cli.eth.contract( abi = ds_token['abi'], bytecode = ds_token['bin'], ) contract_owner = Account(owner_key) console = Console() with console.status('[bold green]Working on tasks...') as status: raw_tx, tx_hash = contract_owner.sign(ds_token_contract.constructor(b'DST').buildTransaction({ 'nonce': 1, 'gas': 10000000000,
import sys sys.path.append('../../..') import time from solcx import compile_files from ammolite import (Cli, HTTPProvider, Account) frontend = sys.argv[1] account_file = sys.argv[2] contract_address = sys.argv[3] compiled_sol = compile_files( ['./contract/PhoneBook.sol', './contract/ConcurrentLibInterface.sol'], output_values=['abi']) phone_book = compiled_sol['./contract/PhoneBook.sol:PhoneBook'] cli = Cli(HTTPProvider(frontend)) contract = cli.eth.contract( abi=phone_book['abi'], address=contract_address, ) accounts = [] with open(account_file, 'r') as f: lines = f.readlines() for l in lines: parts = l.split(',') accounts.append(Account(parts[0])) txs = {} for acc in accounts:
def test_compile_files_output_types(foo_path, key): output = solcx.compile_files([foo_path], output_values=[key]) assert list(output[f"{foo_path.as_posix()}:Foo"]) == [key]
def test_solc_binary(wrapper_mock, foo_path): wrapper_mock.expect(solc_binary=Path("path/to/solc")) solcx.compile_files([foo_path], ["abi"], solc_binary=Path("path/to/solc"), allow_empty=True)
def compile(self, contract_filepaths: List[Path], base_path: Optional[Path] = None) -> List[ContractType]: # TODO: move this to solcx contract_types = [] files = [] solc_version = None for path in contract_filepaths: files.append(path) source = path.read_text() pragma_spec = get_pragma_spec(source) # check if we need to install specified compiler version if pragma_spec: if pragma_spec is not pragma_spec.select( self.installed_versions): solc_version = pragma_spec.select(self.available_versions) if solc_version: solcx.install_solc(solc_version, show_progress=False) else: raise CompilerError( f"Solidity version '{solc_version}' is not available." ) else: solc_version = pragma_spec.select(self.installed_versions) else: solc_version = max(self.installed_versions) if not base_path: # Does support base_path from ape import config base_path = config.contracts_folder cli_base_path = base_path if solc_version >= Version("0.6.9") else None import_remappings = self.get_import_remapping(base_path=cli_base_path) kwargs = { "output_values": [ "abi", "bin", "bin-runtime", "devdoc", "userdoc", ], "solc_version": solc_version, "import_remappings": import_remappings, "optimize": self.config.optimize, } if cli_base_path: kwargs["base_path"] = cli_base_path output = solcx.compile_files(files, **kwargs) def load_dict(data: Union[str, dict]) -> Dict: return data if isinstance(data, dict) else json.loads(data) for contract_name, contract_type in output.items(): contract_id_parts = contract_name.split(":") contract_path = Path(contract_id_parts[0]) contract_type["contractName"] = contract_id_parts[-1] contract_type["sourceId"] = ( str(get_relative_path(base_path / contract_path, base_path)) if base_path and contract_path.is_absolute() else str(contract_path)) contract_type["deploymentBytecode"] = { "bytecode": contract_type["bin"] } contract_type["runtimeBytecode"] = { "bytecode": contract_type["bin-runtime"] } contract_type["userdoc"] = load_dict(contract_type["userdoc"]) contract_type["devdoc"] = load_dict(contract_type["devdoc"]) contract_types.append(ContractType.parse_obj(contract_type)) # Fix source IDs for when compiler did not account for base_path, # such as solidity<0.6.9. for contract_type in contract_types: if contract_type.source_id: source_id_path = Path(contract_type.source_id) if source_id_path.is_absolute(): contract_type.source_id = str( get_relative_path(source_id_path, base_path)) return contract_types
def test_compile_single_file_no_sequence(foo_path): output = solcx.compile_files(foo_path) assert f"{foo_path.as_posix()}:Foo" in output for value in combined_json_values: assert value in output[f"{foo_path.as_posix()}:Foo"]
def _compile(self, root_source_dir: str, other_source_dirs: [str]) -> dict: """Executes the compiler with parameters specified in the json config""" # Allow for optional installation from solcx import compile_files from solcx.exceptions import SolcError self.log.info("Using solidity compiler binary at {}".format( self.__sol_binary_path)) contracts_dir = os.path.join(root_source_dir, self.__compiled_contracts_dir) self.log.info( "Compiling solidity source files at {}".format(contracts_dir)) source_paths = set() source_walker = os.walk(top=contracts_dir, topdown=True) if other_source_dirs is not None: for source_dir in other_source_dirs: other_source_walker = os.walk(top=source_dir, topdown=True) source_walker = itertools.chain(source_walker, other_source_walker) for root, dirs, files in source_walker: for filename in files: if filename.endswith('.sol'): path = os.path.join(root, filename) source_paths.add(path) self.log.debug( "Collecting solidity source {}".format(path)) # Compile with remappings: https://github.com/ethereum/py-solc zeppelin_dir = os.path.join(root_source_dir, self.__zeppelin_library_dir) aragon_dir = os.path.join(root_source_dir, self.__aragon_library_dir) remappings = ( "contracts={}".format(contracts_dir), "zeppelin={}".format(zeppelin_dir), "aragon={}".format(aragon_dir), ) self.log.info("Compiling with import remappings {}".format( ", ".join(remappings))) optimization_runs = self.optimization_runs try: compiled_sol = compile_files(source_files=source_paths, solc_binary=self.__sol_binary_path, import_remappings=remappings, allow_paths=root_source_dir, optimize=True, optimize_runs=optimization_runs) self.log.info( "Successfully compiled {} contracts with {} optimization runs". format(len(compiled_sol), optimization_runs)) 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 test_compile_files_empty(empty_path): with pytest.raises(ContractsNotFound): solcx.compile_files([empty_path])
from typing import Dict, List, Tuple, Optional, Any AttributeDict = Dict[str, Any] GAS_LIMIT = int(os.getenv("GAS_LIMIT", 4712388)) LOG = logging.getLogger("hmt_escrow.eth_bridge") HMTOKEN_ADDR = Web3.toChecksumAddress( os.getenv("HMTOKEN_ADDR", "0x9b0ff099c4e8df24ec077e0ccd46571f915afb25")) CONTRACT_FOLDER = os.path.join(os.path.dirname(os.path.dirname(__file__)), "contracts") CONTRACTS = compile_files([ "{}/Escrow.sol".format(CONTRACT_FOLDER), "{}/EscrowFactory.sol".format(CONTRACT_FOLDER), "{}/HMToken.sol".format(CONTRACT_FOLDER), "{}/HMTokenInterface.sol".format(CONTRACT_FOLDER), "{}/SafeMath.sol".format(CONTRACT_FOLDER), ]) # See more details about the eth-kvstore here: https://github.com/hCaptcha/eth-kvstore KVSTORE_CONTRACT = Web3.toChecksumAddress( os.getenv("KVSTORE_CONTRACT", "0xbcF8274FAb0cbeD0099B2cAFe862035a6217Bf44")) WEB3_POLL_LATENCY = float(os.getenv("WEB3_POLL_LATENCY", 5)) WEB3_TIMEOUT = int(os.getenv("WEB3_TIMEOUT", 240)) def get_w3() -> Web3: """Set up the web3 provider for serving transactions to the ethereum network.
def test_solc_version(wrapper_mock, all_versions, foo_path): solc_binary = solcx.install.get_executable(all_versions) wrapper_mock.expect(solc_binary=solc_binary) solcx.compile_files([foo_path], ["abi"], solc_version=all_versions, allow_empty=True)