def prepare_contracts(web3, config):
addresses = get_contracts_addresses(get_network_name(), config)
if not addresses:
raise AssertionError(f'Cannot find contracts addresses for network {get_network_name()}')
addresses = {name: web3.toChecksumAddress(a) for name, a in addresses.items()}
return addresses
def test_get_ocean_token_address(config):
addresses = util.get_contracts_addresses(config.address_file, "ganache")
assert addresses
assert isinstance(addresses, dict)
assert "Ocean" in addresses
address = get_ocean_token_address(config.address_file, "ganache")
assert address[:2] == "0x", "It is not a token address."
assert address == addresses["Ocean"]
def test_get_dtfactory_address(config):
addresses = util.get_contracts_addresses(config.address_file, "ganache")
assert addresses
assert isinstance(addresses, dict)
assert "DTFactory" in addresses
address = get_dtfactory_address(config.address_file, "ganache")
assert address[:2] == "0x", "It is not a token address."
assert address == addresses["DTFactory"]
def test_get_contracts_addresses(config):
addresses = util.get_contracts_addresses(config.address_file, "ganache")
assert addresses
assert isinstance(addresses, dict)
assert ("DTFactory" and "BFactory" and "FixedRateExchange" and "Metadata"
and "Ocean" in addresses)
assert len(addresses) == 6
for value in addresses.values():
assert value.startswith("0x"), "It is not a token address."
def test_get_contracts_addresses():
config = Config(os.getenv(ENV_CONFIG_FILE))
ConfigProvider.set_config(config)
addresses = util.get_contracts_addresses("ganache", config)
assert addresses
assert isinstance(addresses, dict)
assert ("DTFactory" and "BFactory" and "FixedRateExchange" and "Metadata"
and "Ocean" in addresses)
assert len(addresses) == 5
for _, value in addresses.items():
assert value.startswith("0x")
def test_update_trusted_algorithms():
setup = Setup()
config = ConfigProvider.get_config()
ddo_address = get_contracts_addresses(
"ganache", config)[MetadataContract.CONTRACT_NAME]
ddo_registry = MetadataContract(ddo_address)
# Setup algorithm meta to run raw algorithm
algorithm_ddo = get_registered_algorithm_ddo(
setup.publisher_ocean_instance, setup.publisher_wallet)
# verify the ddo is available in Aquarius
_ = setup.publisher_ocean_instance.assets.resolve(algorithm_ddo.did)
# Dataset with compute service
compute_ddo = get_registered_ddo_with_compute_service(
setup.publisher_ocean_instance,
setup.publisher_wallet,
trusted_algorithms=[algorithm_ddo.did],
)
# verify the ddo is available in Aquarius
_ = setup.publisher_ocean_instance.assets.resolve(compute_ddo.did)
trusted_algo_list = create_publisher_trusted_algorithms(
[algorithm_ddo.did],
setup.publisher_ocean_instance.config.aquarius_url)
compute_ddo.update_compute_privacy(trusted_algorithms=trusted_algo_list,
allow_all=False,
allow_raw_algorithm=False)
tx_id = setup.publisher_ocean_instance.assets.update(
compute_ddo, setup.publisher_wallet)
tx_receipt = ddo_registry.get_tx_receipt(tx_id)
logs = ddo_registry.event_MetadataUpdated.processReceipt(tx_receipt)
assert logs[0].args.dataToken == compute_ddo.data_token_address
wait_for_update(
setup.publisher_ocean_instance,
compute_ddo.did,
"privacy",
{"publisherTrustedAlgorithms": [algorithm_ddo.did]},
)
compute_ddo_updated = setup.publisher_ocean_instance.assets.resolve(
compute_ddo.did)
run_compute_test(
setup.consumer_ocean_instance,
setup.publisher_wallet,
setup.consumer_wallet,
[compute_ddo_updated],
algo_ddo=algorithm_ddo,
)
def test_update_trusted_algorithms(config, web3, algorithm_ddo,
asset_with_trusted):
setup = Setup()
ddo_address = get_contracts_addresses(
config.address_file, "ganache")[MetadataContract.CONTRACT_NAME]
ddo_registry = MetadataContract(web3, ddo_address)
trusted_algo_list = create_publisher_trusted_algorithms(
[algorithm_ddo.did],
setup.publisher_ocean_instance.config.metadata_cache_uri)
asset_with_trusted.update_compute_privacy(
trusted_algorithms=trusted_algo_list,
trusted_algo_publishers=[],
allow_all=False,
allow_raw_algorithm=False,
)
tx_id = setup.publisher_ocean_instance.assets.update(
asset_with_trusted, setup.publisher_wallet)
tx_receipt = ddo_registry.get_tx_receipt(web3, tx_id)
logs = ddo_registry.event_MetadataUpdated.processReceipt(tx_receipt,
errors=DISCARD)
assert logs[0].args.dataToken == asset_with_trusted.data_token_address
wait_for_update(
setup.publisher_ocean_instance,
asset_with_trusted.did,
"privacy",
{"publisherTrustedAlgorithms": [algorithm_ddo.did]},
)
compute_ddo_updated = setup.publisher_ocean_instance.assets.resolve(
asset_with_trusted.did)
run_compute_test(
setup.consumer_ocean_instance,
setup.publisher_wallet,
setup.consumer_wallet,
[compute_ddo_updated],
algo_ddo=algorithm_ddo,
)
def test_metadata_contract(publisher_ocean_instance, config):
ocn = publisher_ocean_instance
alice = get_publisher_wallet()
block = ocn.web3.eth.block_number
ddo_address = get_contracts_addresses(
config.address_file, "ganache")[MetadataContract.CONTRACT_NAME]
ddo_registry = MetadataContract(ocn.web3, ddo_address)
# Tested the event properties.
assert (ddo_registry.event_MetadataCreated.abi["name"] ==
MetadataContract.EVENT_METADATA_CREATED)
assert (ddo_registry.event_MetadataUpdated.abi["name"] ==
MetadataContract.EVENT_METADATA_UPDATED)
# Tested get_event_log for create event.
original_ddo = create_asset(ocn, alice)
assert original_ddo, "Create asset failed."
asset_id = original_ddo.asset_id
creation_log = ddo_registry.get_event_log(
ddo_registry.EVENT_METADATA_CREATED, block, asset_id, 30)
assert creation_log, "No ddo created event."
assert creation_log.args.createdBy == alice.address
assert (creation_log.args.createdBy == alice.address
), "The event is not created by the publisher."
assert (creation_log.event == ddo_registry.EVENT_METADATA_CREATED
), "Different event types."
# Tested get_event_log for update event.
ddo = wait_for_ddo(ocn, original_ddo.did)
_ = ocn.assets.update(ddo, alice)
updating_log = ddo_registry.get_event_log(
ddo_registry.EVENT_METADATA_UPDATED, block, asset_id, 30)
assert updating_log, "No ddo updated event."
assert (updating_log.args.updatedBy == alice.address
), "The event is not updated by the publisher."
assert (updating_log.event == ddo_registry.EVENT_METADATA_UPDATED
), "Different event types."
def __init__(self, config=None, data_provider=None):
"""Initialize Ocean class.
>> # Make a new Ocean instance
>> ocean = Ocean({...})
This class provides the main top-level functions in ocean protocol:
* Publish assets metadata and associated services
* Each asset is assigned a unique DID and a DID Document (DDO)
* The DDO contains the asset's services including the metadata
* The DID is registered on-chain with a URL of the metadata store
to retrieve the DDO from
>> asset = ocean.assets.create(metadata, publisher_wallet)
* Discover/Search assets via the current configured metadata store (Aquarius)
>> assets_list = ocean.assets.search('search text')
An instance of Ocean is parameterized by a `Config` instance.
:param config: Config instance
:param data_provider: DataServiceProvider instance
"""
# Configuration information for the market is stored in the Config class
# config = Config(filename=config_file, options_dict=config_dict)
if not config:
try:
config = ConfigProvider.get_config()
except AssertionError:
config = Config(os.getenv(ENV_CONFIG_FILE))
ConfigProvider.set_config(config)
if isinstance(config, dict):
# fallback to metadataStoreUri
cache_key = ("metadataCacheUri" if ("metadataCacheUri" in config)
else "metadataStoreUri")
aqua_url = config.get(
cache_key, config.get("aquarius.url", "http://localhost:5000"))
config_dict = {
"eth-network": {
"network": config.get("network", "")
},
"resources": {
"aquarius.url":
aqua_url,
"provider.url":
config.get("providerUri", "http://localhost:8030"),
},
}
config = Config(options_dict=config_dict)
ConfigProvider.set_config(config)
self._config = config
ContractHandler.set_artifacts_path(self._config.artifacts_path)
Web3Provider.init_web3(
provider=get_web3_connection_provider(self._config.network_url))
self._web3 = Web3Provider.get_web3()
if not data_provider:
data_provider = DataServiceProvider
network = Web3Helper.get_network_name()
addresses = get_contracts_addresses(network, self._config)
self.assets = OceanAssets(
self._config, data_provider,
addresses.get(MetadataContract.CONTRACT_NAME))
self.services = OceanServices()
self.auth = OceanAuth(self._config.storage_path)
self.compute = OceanCompute(self.auth, self._config, data_provider)
ocean_address = get_ocean_token_address(network)
self.pool = OceanPool(ocean_address, get_bfactory_address(network))
self.exchange = OceanExchange(
ocean_address,
FixedRateExchange.configured_address(
network or Web3Helper.get_network_name(),
ConfigProvider.get_config().address_file,
),
self.config,
)
logger.debug("Ocean instance initialized: ")
def _get_exchange_address(config):
"""Helper function to retrieve a known exchange address."""
return get_contracts_addresses(config.address_file,
_NETWORK)[FixedRateExchange.CONTRACT_NAME]
def _get_exchange_address():
"""Helper function to retrieve a known exchange address."""
return get_contracts_addresses(
_NETWORK, ConfigProvider.get_config())[FixedRateExchange.CONTRACT_NAME]
def test_ddo_on_chain():
config = ConfigProvider.get_config()
ddo_address = get_contracts_addresses(
"ganache", config)[MetadataContract.CONTRACT_NAME]
dtfactory_address = get_contracts_addresses(
"ganache", config)[DTFactory.CONTRACT_NAME]
ddo_registry = MetadataContract(ddo_address)
wallet = get_publisher_wallet()
web3 = Web3Provider.get_web3()
dtfactory = DTFactory(dtfactory_address)
tx_id = dtfactory.createToken("", "dt1", "dt1", 1000, wallet)
dt = DataToken(dtfactory.get_token_address(tx_id))
# test create ddo
asset = get_ddo_sample(dt.address)
old_name = asset.metadata["main"]["name"]
txid = ddo_registry.create(
asset.asset_id, b"", lzma.compress(web3.toBytes(text=asset.as_text())),
wallet)
assert ddo_registry.verify_tx(txid), f"create ddo failed: txid={txid}"
logs = ddo_registry.event_MetadataCreated.processReceipt(
ddo_registry.get_tx_receipt(txid))
assert logs, f"no logs found for create ddo tx {txid}"
log = logs[0]
assert add_0x_prefix(log.args.dataToken) == asset.asset_id
# read back the asset ddo from the event log
ddo_text = web3.toText(lzma.decompress(log.args.data))
assert ddo_text == asset.as_text(), "ddo text does not match original."
_asset = Asset(json_text=ddo_text)
assert _asset.did == asset.did, "did does not match."
name = _asset.metadata["main"]["name"]
assert name == old_name, f"name does not match: {name} != {old_name}"
# test_update ddo
asset.metadata["main"]["name"] = "updated name for test"
txid = ddo_registry.update(
asset.asset_id, b"", lzma.compress(web3.toBytes(text=asset.as_text())),
wallet)
assert ddo_registry.verify_tx(txid), f"update ddo failed: txid={txid}"
logs = ddo_registry.event_MetadataUpdated.processReceipt(
ddo_registry.get_tx_receipt(txid))
assert logs, f"no logs found for update ddo tx {txid}"
log = logs[0]
assert add_0x_prefix(log.args.dataToken) == asset.asset_id
# read back the asset ddo from the event log
ddo_text = web3.toText(lzma.decompress(log.args.data))
assert ddo_text == asset.as_text(), "ddo text does not match original."
_asset = Asset(json_text=ddo_text)
assert (_asset.metadata["main"]["name"] == "updated name for test"
), "name does not seem to be updated."
assert DataToken(asset.asset_id).contract_concise.isMinter(wallet.address)
# test update fails from wallet other than the original publisher
bob = get_consumer_wallet()
try:
txid = ddo_registry.update(
asset.asset_id, b"",
lzma.compress(web3.toBytes(text=asset.as_text())), bob)
assert ddo_registry.verify_tx(
txid) is False, f"update ddo failed: txid={txid}"
logs = ddo_registry.event_MetadataUpdated.processReceipt(
ddo_registry.get_tx_receipt(txid))
assert (
not logs
), f"should be no logs for MetadataUpdated, but seems there are some logs: tx {txid}, logs {logs}"
except ValueError:
print("as expected, only owner can update a published ddo.")
# test ddoOwner
assert DataToken(asset.asset_id).contract_concise.isMinter(
wallet.address
), (f"ddo owner does not match the expected publisher address {wallet.address}, "
f"owner is {DataToken(asset.asset_id).contract_concise.minter(wallet.address)}"
)
def _get_exchange_address():
return get_contracts_addresses(
_NETWORK, ConfigProvider.get_config())[FixedRateExchange.CONTRACT_NAME]
def __init__(
self, config: Union[Dict, Config], data_provider: Optional[Type] = None
) -> None:
"""Initialize Ocean class.
Usage: Make a new Ocean instance
`ocean = Ocean({...})`
This class provides the main top-level functions in ocean protocol:
1. Publish assets metadata and associated services
- Each asset is assigned a unique DID and a DID Document (DDO)
- The DDO contains the asset's services including the metadata
- The DID is registered on-chain with a URL of the metadata store
to retrieve the DDO from
`asset = ocean.assets.create(metadata, publisher_wallet)`
2. Discover/Search assets via the current configured metadata store (Aquarius)
- Usage:
`assets_list = ocean.assets.search('search text')`
An instance of Ocean is parameterized by a `Config` instance.
:param config: `Config` instance
:param data_provider: `DataServiceProvider` instance
"""
if isinstance(config, dict):
# fallback to metadataStoreUri
cache_key = (
"metadataCacheUri"
if ("metadataCacheUri" in config)
else "metadataStoreUri"
)
metadata_cache_uri = config.get(
cache_key, config.get("metadata_cache_uri", "http://localhost:5000")
)
config_dict = {
"eth-network": {"network": config.get("network", "")},
"resources": {
"metadata_cache_uri": metadata_cache_uri,
"provider.url": config.get("providerUri", "http://localhost:8030"),
},
}
config = Config(options_dict=config_dict)
self.config = config
self.web3 = get_web3(self.config.network_url)
if not data_provider:
data_provider = DataServiceProvider
network = get_network_name(web3=self.web3)
addresses = get_contracts_addresses(self.config.address_file, network)
self.assets = OceanAssets(
self.config,
self.web3,
data_provider,
addresses.get(MetadataContract.CONTRACT_NAME),
)
self.compute = OceanCompute(self.config, data_provider)
ocean_address = get_ocean_token_address(self.config.address_file, network)
self.pool = OceanPool(
self.web3,
ocean_address,
get_bfactory_address(self.config.address_file, network),
get_dtfactory_address(self.config.address_file, network),
)
self.exchange = OceanExchange(
self.web3,
ocean_address,
FixedRateExchange.configured_address(network, self.config.address_file),
self.config,
)
logger.debug("Ocean instance initialized: ")
