def init_components(config=None): if config is None: config = Config(os.getenv(ENV_CONFIG_FILE)) ConfigProvider.set_config(config) Web3Provider.init_web3(provider=get_web3_connection_provider(config.network_url)) ContractHandler.set_artifacts_path(config.artifacts_path)
def setup_network(config_file=None): config = Config(filename=config_file) if config_file else get_config() network_url = config.network_url artifacts_path = get_artifacts_path(config) ContractHandler.set_artifacts_path(artifacts_path) if network_url.startswith('http'): provider = CustomHTTPProvider elif network_url.startswith('wss'): provider = WebsocketProvider else: raise AssertionError(f'Unsupported network url {network_url}. Must start with http or wss.') Web3Provider.init_web3(provider=provider(network_url)) if network_url.startswith('wss'): from web3.middleware import geth_poa_middleware Web3Provider.get_web3().middleware_stack.inject(geth_poa_middleware, layer=0) init_account_envvars() wallet = get_provider_wallet() if wallet is None: raise AssertionError(f'Ocean Provider cannot run without a valid ' f'ethereum account. `PROVIDER_PRIVATE_KEY` was not found in the environment ' f'variables. \nENV WAS: {sorted(os.environ.items())}') if not wallet.private_key: raise AssertionError(f'Ocean Provider cannot run without a valid ' f'ethereum private key..')
def setup_network(config_file=None): config = Config(filename=config_file) if config_file else get_config() network_url = config.network_url artifacts_path = get_artifacts_path(config) ContractHandler.set_artifacts_path(artifacts_path) w3_connection_provider = get_web3_connection_provider(network_url) Web3Provider.init_web3(provider=w3_connection_provider) if network_url.startswith("wss"): from web3.middleware import geth_poa_middleware Web3Provider.get_web3().middleware_stack.inject(geth_poa_middleware, layer=0) init_account_envvars() wallet = get_provider_wallet() if wallet is None: raise AssertionError( f"Ocean Provider cannot run without a valid " f"ethereum account. `PROVIDER_PRIVATE_KEY` was not found in the environment " f"variables. \nENV WAS: {sorted(os.environ.items())}") if not wallet.private_key: raise AssertionError( "Ocean Provider cannot run without a valid ethereum private key.")
def setup_all(): config = ExampleConfig.get_config() ConfigProvider.set_config(config) Web3Provider.init_web3( provider=get_web3_connection_provider(config.network_url)) ContractHandler.set_artifacts_path(config.artifacts_path) network = Web3Helper.get_network_name() wallet = get_ganache_wallet() if network in ["ganache", "development"] and wallet: print( f"sender: {wallet.key}, {wallet.address}, {wallet.password}, {wallet.keysStr()}" ) print( f"sender balance: {Web3Helper.from_wei(Web3Helper.get_ether_balance(wallet.address))}" ) assert Web3Helper.from_wei(Web3Helper.get_ether_balance( wallet.address)) > 10 from ocean_lib.models.data_token import DataToken OCEAN_token = DataToken(get_ocean_token_address(network)) amt_distribute = 1000 amt_distribute_base = to_base_18(float(amt_distribute)) for w in (get_publisher_wallet(), get_consumer_wallet()): if Web3Helper.from_wei(Web3Helper.get_ether_balance( w.address)) < 2: Web3Helper.send_ether(wallet, w.address, 4) if OCEAN_token.token_balance(w.address) < 100: OCEAN_token.transfer(w.address, amt_distribute_base, from_wallet=wallet)
def test1(): # ocean instance config = ExampleConfig.get_config() ConfigProvider.set_config(config) Web3Provider.init_web3( provider=get_web3_connection_provider(config.network_url)) ContractHandler.set_artifacts_path(config.artifacts_path) ocean = Ocean(config) OCEAN_address_before = ocean.OCEAN_address # deploy, distribute, etc deploy_fake_OCEAN() # test: OCEAN address should have changed OCEAN_address_after = ocean.OCEAN_address assert OCEAN_address_before != OCEAN_address_after # test: TEST_PRIVATE_KEY{1,2} should each hold OCEAN wallet1 = Wallet(ocean.web3, private_key=os.getenv("TEST_PRIVATE_KEY1")) wallet2 = Wallet(ocean.web3, private_key=os.getenv("TEST_PRIVATE_KEY2")) OCEAN_after = BToken(ocean.OCEAN_address) assert OCEAN_after.balanceOf(wallet1.address) > 0 assert OCEAN_after.balanceOf(wallet2.address) > 0
def run_events_monitor(): setup_logging() logger.info('EventsMonitor: preparing') required_env_vars = ['EVENTS_RPC', 'CONFIG_FILE'] for envvar in required_env_vars: if not os.getenv(envvar): raise AssertionError( f'env var {envvar} is missing, make sure to set the following ' f'environment variables before starting the events monitor: {required_env_vars}' ) network_rpc = os.environ.get('EVENTS_RPC', 'http:127.0.0.1:8545') config_file = os.getenv('CONFIG_FILE', 'config.ini') logger.info( f'EventsMonitor: starting with the following values: rpc={network_rpc}' ) ConfigProvider.set_config(Config(config_file)) from ocean_lib.ocean.util import get_web3_connection_provider Web3Provider.init_web3(provider=get_web3_connection_provider(network_rpc)) ContractHandler.set_artifacts_path(get_artifacts_path()) if get_network_name().lower() == 'rinkeby': from web3.middleware import geth_poa_middleware Web3Provider.get_web3().middleware_stack.inject(geth_poa_middleware, layer=0) monitor = EventsMonitor(Web3Provider.get_web3(), config_file) monitor.start_events_monitor() logger.info(f'EventsMonitor: started') while True: time.sleep(5)
def test_get_and_has__name_only(): """Tests get() and has() from name-only queries, which also call _load() and read_abi_from_file().""" contract = ContractHandler.get("DataTokenTemplate") assert contract.address[:2] == "0x" assert "totalSupply" in str(contract.abi) assert ContractHandler.has("DataTokenTemplate") assert not ContractHandler.has("foo name")
def test_set_artifacts_path__deny_change_to_same(): path_before = copy.copy(ContractHandler.artifacts_path) assert path_before is not None assert ContractHandler._contracts ContractHandler.set_artifacts_path(path_before) assert ContractHandler.artifacts_path == path_before assert ContractHandler._contracts # cache should *not* have reset
def test_set_artifacts_path__allow_change(): path_before = copy.copy(ContractHandler.artifacts_path) assert path_before is not None assert ContractHandler._contracts ContractHandler.set_artifacts_path("new path") assert ContractHandler.artifacts_path == "new path" assert not ContractHandler._contracts # cache should have reset
def test_set_artifacts_path__allow_change(): """Tests that a correct artifacts path can be set (happy flow).""" path_before = copy.copy(ContractHandler.artifacts_path) assert path_before is not None assert ContractHandler._contracts ContractHandler.set_artifacts_path("new path") assert ContractHandler.artifacts_path == "new path" assert not ContractHandler._contracts # cache should have reset
def test_set_artifacts_path__deny_change_to_empty(): """Tests can not set empty artifacts path.""" path_before = copy.copy(ContractHandler.artifacts_path) assert path_before is not None assert ContractHandler._contracts ContractHandler.set_artifacts_path(None) # it should deny this assert ContractHandler.artifacts_path == path_before assert ContractHandler._contracts # cache should *not* have reset
def test_load__name_and_address(network, example_config): """Tests load() from (name, address) query.""" addresses = ContractHandler.get_contracts_addresses( network, example_config.address_file) target_address = addresses["DTFactory"] test_tuple = ("DTFactory", target_address) assert test_tuple not in ContractHandler._contracts ContractHandler._load("DTFactory", target_address) assert test_tuple in ContractHandler._contracts
def __init__(self, address: [str, None], abi_path=None): self.name = self.contract_name assert self.name, 'contract_name property needs to be implemented in subclasses.' if not abi_path: abi_path = ContractHandler.artifacts_path assert abi_path, f'abi_path is required, got {abi_path}' self.contract_concise = ContractHandler.get_concise_contract(self.name, address) self.contract = ContractHandler.get(self.name, address) assert not address or (self.contract.address == address and self.address == address) assert self.contract_concise is not None
def test_load__name_and_address(network, example_config): # test load() from (name, address) query addresses = ContractHandler.get_contracts_addresses( network, example_config.address_file) target_address = addresses["DTFactory"] tup = ("DTFactory", target_address) assert tup not in ContractHandler._contracts contract = ContractHandler._load("DTFactory", target_address) assert ContractHandler._contracts[tup] == contract
def initialize(private_key): load_dotenv(".env") config = Config(os.getenv('config.ini')) config = Config(os.getenv('config.ini')) print(config.network_url) # config.network_url="https://rinkeby.infura.io/v3/31d95be121a545b688a0e07e4de4d256" ConfigProvider.set_config(config) Web3Provider.init_web3( provider=get_web3_connection_provider(config.network_url)) ContractHandler.set_artifacts_path(config.artifacts_path) ocean = Ocean() wallet = Wallet(ocean.web3, private_key=private_key) return ocean, wallet
def test_load__name_only(): # test load() from name-only query assert "DTFactory" not in ContractHandler._contracts contract = ContractHandler._load("DTFactory") assert ContractHandler._contracts["DTFactory"] == contract
def test_set(): contract = ContractHandler.get("DataTokenTemplate") address = contract.address ContractHandler.set("second_name", contract) # did it store in (name) key? tup = ContractHandler._contracts[ "second_name"] # (contract, contract_concise) assert len(tup) == 2 assert tup[0].address == address assert isinstance(tup[1], ConciseContract) # did it store in (name, address) key? tup2 = ContractHandler._contracts[("second_name", address)] assert tup2 == tup
def test_read_abi_from_file__example_config__happy_path(example_config): assert "https" not in str(ContractHandler.artifacts_path) contract_definition = ContractHandler.read_abi_from_file( "DTFactory", ContractHandler.artifacts_path) assert contract_definition["contractName"] == "DTFactory" assert "createToken" in str(contract_definition["abi"])
def get_contracts_addresses(network, config): addresses = {} try: addresses = ContractHandler.get_contracts_addresses( network, config.address_file ) except Exception as e: print( f"error reading contract addresses: {e}.\n" f"artifacts path is {ContractHandler.artifacts_path}, address file is {config.address_file}" ) if not addresses: print( f"cannot find contract addresses: \n" f"artifacts path is {ContractHandler.artifacts_path}, address file is {config.address_file}" ) print(f"address file exists? {os.path.exists(config.address_file)}") print( f"artifacts path exists? {os.path.exists(ContractHandler.artifacts_path)}" ) print( f"contents of artifacts folder: \n" f"{os.listdir(ContractHandler.artifacts_path)}" ) return addresses or {}
def deploy(cls, web3, deployer_wallet: Wallet, abi_path: str = '', *args): """ Deploy the DataTokenTemplate and DTFactory contracts to the current network. :param web3: :param abi_path: :param deployer_wallet: Wallet instance :return: smartcontract address of this contract """ if not abi_path: abi_path = ContractHandler.artifacts_path assert abi_path, f'abi_path is required, got {abi_path}' w3 = web3 _json = ContractHandler.read_abi_from_file(cls.CONTRACT_NAME, abi_path) _contract = w3.eth.contract(abi=_json['abi'], bytecode=_json['bytecode']) built_tx = _contract.constructor(*args)\ .buildTransaction({'from': deployer_wallet.address}) if 'gas' not in built_tx: built_tx['gas'] = web3.eth.estimateGas(built_tx) raw_tx = deployer_wallet.sign_tx(built_tx) logging.debug( f'Sending raw tx to deploy contract {cls.CONTRACT_NAME}, signed tx hash: {raw_tx.hex()}' ) tx_hash = web3.eth.sendRawTransaction(raw_tx) return cls.get_tx_receipt(tx_hash, timeout=60).contractAddress
def setup_all(request): # a test can skip setup_all() via decorator "@pytest.mark.nosetup_all" if "nosetup_all" in request.keywords: return config = ExampleConfig.get_config() ConfigProvider.set_config(config) Web3Provider.init_web3( provider=get_web3_connection_provider(config.network_url)) ContractHandler.set_artifacts_path(config.artifacts_path) wallet = get_ganache_wallet() if not wallet: return addresses_file = config.address_file if not os.path.exists(addresses_file): return with open(addresses_file) as f: network_addresses = json.load(f) print( f"sender: {wallet.key}, {wallet.address}, {wallet.password}, {wallet.keysStr()}" ) print(f"sender balance: {from_wei(get_ether_balance(wallet.address))}") assert (from_wei(get_ether_balance(wallet.address)) > 10), "Ether balance less than 10." from ocean_lib.models.data_token import DataToken OCEAN_token = DataToken(address=network_addresses["development"]["Ocean"]) amt_distribute = 1000 amt_distribute_base = to_base_18(float(amt_distribute)) for w in (get_publisher_wallet(), get_consumer_wallet()): if from_wei(get_ether_balance(w.address)) < 2: send_ether(wallet, w.address, 4) if OCEAN_token.token_balance(w.address) < 100: OCEAN_token.mint(wallet.address, amt_distribute_base, from_wallet=wallet) OCEAN_token.transfer(w.address, amt_distribute_base, from_wallet=wallet)
def mint_fake_OCEAN(): """ Does the following: 1. Mints tokens 2. Distributes tokens to TEST_PRIVATE_KEY1 and TEST_PRIVATE_KEY2 """ config = ExampleConfig.get_config() ConfigProvider.set_config(config) Web3Provider.init_web3( provider=get_web3_connection_provider(config.network_url)) ContractHandler.set_artifacts_path(config.artifacts_path) addresses_file = config.address_file ocean = get_publisher_ocean_instance() web3 = ocean.web3 with open(addresses_file) as f: network_addresses = json.load(f) network = "development" deployer_wallet = get_ganache_wallet() OCEAN_token = DataToken(address=network_addresses[network]["Ocean"]) amt_distribute = 1000 amt_distribute_base = to_base_18(float(amt_distribute)) OCEAN_token.mint(deployer_wallet.address, 2 * amt_distribute_base, from_wallet=deployer_wallet) for key_label in ["TEST_PRIVATE_KEY1", "TEST_PRIVATE_KEY2"]: key = os.environ.get(key_label) if not key: continue w = Wallet(web3, private_key=key) if OCEAN_token.token_balance(w.address) < 1000: OCEAN_token.transfer(w.address, amt_distribute_base, from_wallet=deployer_wallet) if from_wei(get_ether_balance(w.address)) < 2: send_ether(deployer_wallet, w.address, 4)
def events_object(): global EVENTS_INSTANCE if not EVENTS_INSTANCE: config_file = os.getenv('CONFIG_FILE', 'config.ini') network_rpc = os.environ.get('EVENTS_RPC', 'http://127.0.0.1:8545') ConfigProvider.set_config(Config(config_file)) from ocean_lib.ocean.util import get_web3_connection_provider Web3Provider.init_web3( provider=get_web3_connection_provider(network_rpc)) ContractHandler.set_artifacts_path(get_artifacts_path()) EVENTS_INSTANCE = EventsMonitor(Web3Provider.get_web3(), app.config['CONFIG_FILE']) EVENTS_INSTANCE.store_last_processed_block(0) return EVENTS_INSTANCE
def test_set(): """Tests setting of a DataTokenTemplate on a Contract.""" contract = ContractHandler.get("DataTokenTemplate") address = contract.address ContractHandler.set("second_name", contract) # result format is a tuple of (contract, contract_concise) # did it store in (name) key? result = ContractHandler._contracts["second_name"] assert len(result) == 2 assert result[0].address == address assert isinstance(result[1], ConciseContract) # did it store in (name, address) key? result2 = ContractHandler._contracts[("second_name", address)] assert result2 == result
def test_read_abi_from_file__example_config__bad_contract_name(example_config): assert "https" not in str(ContractHandler.artifacts_path) base_path = ContractHandler.artifacts_path target_filename = os.path.join(base_path, "DTFactoryFOO.json") assert not os.path.exists(target_filename) # should fail due to this contract_definition = ContractHandler.read_abi_from_file( "DTFactoryFOO", ContractHandler.artifacts_path) assert contract_definition is None
def __init__(self, address: [str, None], abi_path=None): """Initialises Contract Base object. The contract name attribute and abi_path are required. """ self.name = self.contract_name assert ( self.name ), "contract_name property needs to be implemented in subclasses." if not abi_path: abi_path = ContractHandler.artifacts_path assert abi_path, f"abi_path is required, got {abi_path}" self.contract_concise = ContractHandler.get_concise_contract(self.name, address) self.contract = ContractHandler.get(self.name, address) assert not address or ( self.contract.address == address and self.address == address ) assert self.contract_concise is not None
def test_issue185_unit(monkeypatch): """For #185, unit-test the root cause method, which is load""" setup_issue_185(monkeypatch) # ensure that conftest::setup_all() was not called assert ConfigProvider._config is None assert Web3Provider._web3 is None assert ContractHandler._contracts == dict() assert ContractHandler.artifacts_path is None # actual test. Imports only come now, to avoid setting class-level attributes # isort: off from ocean_lib.ocean.ocean import Ocean from ocean_lib.web3_internal.wallet import Wallet # isort: on private_key = os.getenv("TEST_PRIVATE_KEY1") config = {"network": os.getenv("NETWORK_URL")} ocean = Ocean(config) # Ensure it's using a path like '/home/trentmc/ocean.py/venv/artifacts' assert os.path.exists(ocean._config.artifacts_path) assert "venv/artifacts" in ocean._config.artifacts_path wallet = Wallet(ocean.web3, private_key=private_key) assert wallet is not None # At this point, shouldn't have any contracts cached assert ContractHandler._contracts == {} # This is the call that causes problems in system test. contract = ContractHandler._get("DataTokenTemplate", None) assert contract is not None # The first call may have caused caching. So call again:) contract = ContractHandler._get("DataTokenTemplate", None) assert contract is not None
def run_scenario(): config = Config('config.ini') ocean = Ocean(config) wallet = Wallet( ocean.web3, 0x376e05899a4ae00463a3a607c774069b7d6a647860dba723f39b735c91238ddf, None, "EARLYTOBEDANDEARLYTORISE") ConfigProvider.set_config(config) Web3Provider.init_web3( provider=get_web3_connection_provider(config.network_url)) ContractHandler.set_artifacts_path(config.artifacts_path) print(dir(wallet)) print(wallet.address) print(config.network_url) print(config.provider_url) print(config.network_url) print(config.artifacts_path) data_token = ocean.create_data_token('S1Seven', 'S1SV', from_wallet=wallet) print(f'created new datatoken with address {data_token.address}') token_address = data_token.address print(token_address) '''
def test_get_contracts_addresses_example_config(network, example_config): """Tests that an address can be set if using testing config.""" # ensure we're testing locally assert network in ["ganache", "development"] # do we get addresses for every contract? addresses = ContractHandler.get_contracts_addresses( network, example_config.address_file) assert set(addresses.keys()) == set( ["DTFactory", "BFactory", "FixedRateExchange", "Metadata", "Ocean"]) # are address values sane? for address in addresses.values(): assert address[0:2] == "0x"
def test_get_contracts_addresses_good_path_use_network_alias(tmp_path): """Tests that an address with a network alias can be set on a Contract.""" assert ContractHandler.network_alias == {"ganache": "development"} # create & fill test file d = tmp_path / "subdir" d.mkdir() address_file = d / "address.json" address_file.write_text('{"development" : "myvals"}') # not "ganache" # the main test addresses = ContractHandler.get_contracts_addresses( network="ganache", address_file=address_file) assert addresses == "myvals"