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 ddo_registry(self):
return MetadataContract(self._metadata_registry_address)
def get_registered_ddo(client, wallet, metadata, service_descriptor):
aqua = Aquarius('http://localhost:5000')
ddo_service_endpoint = aqua.get_service_endpoint()
metadata_store_url = json.dumps({'t': 1, 'url': ddo_service_endpoint})
# Create new data token contract
addresses = get_contracts_addresses(get_address_file())
dt_address = addresses.get(DTFactory.CONTRACT_NAME)
if dt_address:
factory_contract = DTFactory(dt_address)
else:
factory_contract = new_factory_contract()
ddo_contract_address = addresses.get(MetadataContract.CONTRACT_NAME)
metadata_contract = MetadataContract(ddo_contract_address)
tx_id = factory_contract.createToken(metadata_store_url, 'DataToken1',
'DT1', to_base_18(1000000), wallet)
dt_contract = DataToken(factory_contract.get_token_address(tx_id))
if not dt_contract:
raise AssertionError('Creation of data token contract failed.')
ddo = Asset()
ddo.data_token_address = dt_contract.address
metadata_service_desc = ServiceDescriptor.metadata_service_descriptor(
metadata, ddo_service_endpoint)
service_descriptors = list([
ServiceDescriptor.authorization_service_descriptor(
'http://localhost:12001')
])
service_descriptors.append(service_descriptor)
service_type = service_descriptor[0]
service_descriptors = [metadata_service_desc] + service_descriptors
services = ServiceFactory.build_services(service_descriptors)
checksums = dict()
for service in services:
checksums[str(service.index)] = checksum(service.main)
# Adding proof to the ddo.
ddo.add_proof(checksums, wallet)
did = ddo.assign_did(f'did:op:{remove_0x_prefix(ddo.data_token_address)}')
ddo_service_endpoint.replace('{did}', did)
services[0].set_service_endpoint(ddo_service_endpoint)
stype_to_service = {s.type: s for s in services}
_service = stype_to_service[service_type]
for service in services:
ddo.add_service(service)
# ddo.proof['signatureValue'] = ocean_lib.sign_hash(
# did_to_id_bytes(did), account)
ddo.add_public_key(did, wallet.address)
ddo.add_authentication(did, PUBLIC_KEY_TYPE_RSA)
# if not plecos.is_valid_dict_local(ddo.metadata):
# print(f'invalid metadata: {plecos.validate_dict_local(ddo.metadata)}')
# assert False, f'invalid metadata: {plecos.validate_dict_local(ddo.metadata)}'
files_list_str = json.dumps(metadata['main']['files'])
encrypted_files = encrypt_document(client, did, files_list_str, wallet)
# encrypted_files = do_encrypt(files_list_str, provider_wallet)
# only assign if the encryption worked
if encrypted_files:
index = 0
for file in metadata['main']['files']:
file['index'] = index
index = index + 1
del file['url']
metadata['encryptedFiles'] = encrypted_files
web3 = Web3Provider.get_web3()
block = web3.eth.blockNumber
try:
data = lzma.compress(web3.toBytes(text=ddo.as_text()))
tx_id = metadata_contract.create(ddo.asset_id, bytes([1]), data,
wallet)
if not metadata_contract.verify_tx(tx_id):
raise AssertionError(
f'create DDO on-chain failed, transaction status is 0. Transaction hash is {tx_id}'
)
except Exception as e:
print(f'error publishing ddo {ddo.did} in Aquarius: {e}')
raise
log = metadata_contract.get_event_log(
metadata_contract.EVENT_METADATA_CREATED, block, ddo.asset_id, 30)
assert log, f'no ddo created event.'
ddo = wait_for_ddo(aqua, ddo.did)
assert ddo, f'resolve did {ddo.did} failed.'
return ddo
def main():
network = 'ganache'
private_key = os.getenv('EVENTS_TESTS_PRIVATE_KEY')
network_rpc = os.getenv('EVENTS_RPC', 'http://127.0.0.1:8545')
config = Config(os.getenv('CONFIG_FILE'))
ConfigProvider.set_config(config)
# artifacts_path = os.getenv('ARTIFACTS_PATH', )
artifacts_path = config.artifacts_path
address_file = Path(
os.getenv('ADDRESS_FILE',
os.path.join(artifacts_path,
'address.json'))).expanduser().resolve()
print(f'deploying contracts and saving addresses in {address_file}')
Web3Provider.init_web3(provider=get_web3_connection_provider(network_rpc))
ContractHandler.set_artifacts_path(artifacts_path)
web3 = Web3Provider.get_web3()
addresses = dict()
if os.path.exists(address_file):
with open(address_file) as f:
network_addresses = json.load(f)
else:
network_addresses = {network: {}}
_addresses = network_addresses[network]
# ****SET ENVT****
# grab vars
factory_deployer_private_key = private_key
# ****SEE FUNDS****
print(
"Keys:\n%s\n" %
Wallet(web3=web3, private_key=factory_deployer_private_key).keysStr())
# ****DEPLOY****
deployer_wallet = Wallet(web3, private_key=factory_deployer_private_key)
minter_addr = deployer_wallet.address
cap = 2**255
print("****Deploy DataTokenTemplate: begin****")
dt_address = DataToken.deploy(web3, deployer_wallet, artifacts_path,
'Template Contract', 'TEMPLATE', minter_addr,
DataToken.DEFAULT_CAP_BASE,
DTFactory.FIRST_BLOB, minter_addr)
addresses[DataToken.CONTRACT_NAME] = dt_address
print("****Deploy DataTokenTemplate: done****\n")
print("****Deploy DTFactory: begin****")
dtfactory = DTFactory(
DTFactory.deploy(web3, deployer_wallet, artifacts_path, dt_address,
minter_addr))
addresses[DTFactory.CONTRACT_NAME] = dtfactory.address
print("****Deploy DTFactory: done****\n")
print("****Deploy BPool: begin****")
bpool_address = BPool.deploy(web3, deployer_wallet, artifacts_path)
bpool_template = BPool(bpool_address)
addresses[BPool.CONTRACT_NAME] = bpool_address
print("****Deploy BPool: done****\n")
print("****Deploy 'BFactory': begin****")
bfactory_address = BFactory.deploy(web3, deployer_wallet, artifacts_path,
bpool_template.address)
bfactory = BFactory(bfactory_address)
addresses[BFactory.CONTRACT_NAME] = bfactory_address
print("****Deploy 'BFactory': done****\n")
print("****Deploy 'FixedRateExchange': begin****")
addresses[FixedRateExchange.CONTRACT_NAME] = FixedRateExchange.deploy(
web3, deployer_wallet, artifacts_path)
print("****Deploy 'FixedRateExchange': done****\n")
print("****Deploy 'Metadata': begin****")
addresses[MetadataContract.CONTRACT_NAME] = MetadataContract.deploy(
web3, deployer_wallet, artifacts_path)
print("****Deploy 'Metadata': done****\n")
if network == 'ganache' and 'Ocean' not in _addresses:
print("****Deploy fake OCEAN: begin****")
# For simplicity, hijack DataTokenTemplate.
minter_addr = deployer_wallet.address
OCEAN_cap = 1410 * 10**6 # 1.41B
OCEAN_cap_base = to_base_18(float(OCEAN_cap))
OCEAN_token = DataToken(
DataToken.deploy(web3, deployer_wallet, artifacts_path, 'Ocean',
'OCEAN', minter_addr, OCEAN_cap_base, '',
minter_addr))
addresses["Ocean"] = OCEAN_token.address
print("****Deploy fake OCEAN: done****\n")
print("****Mint fake OCEAN: begin****")
OCEAN_token.mint(minter_addr,
OCEAN_cap_base,
from_wallet=deployer_wallet)
print("****Mint fake OCEAN: done****\n")
print("****Distribute fake OCEAN: begin****")
amt_distribute = 1000
amt_distribute_base = to_base_18(float(amt_distribute))
for key_label in [
'EVENTS_TESTS_PRIVATE_KEY', 'EVENTS_TESTS_PRIVATE_KEY2'
]:
key = os.environ.get(key_label)
if not key:
continue
dst_address = privateKeyToAddress(key)
try:
OCEAN_token.transfer(dst_address,
amt_distribute_base,
from_wallet=deployer_wallet)
except ValueError:
# handle nonce issue
time.sleep(3)
OCEAN_token.transfer(dst_address,
amt_distribute_base,
from_wallet=deployer_wallet)
print("****Distribute fake OCEAN: done****\n")
network_addresses[network].update(addresses)
with open(address_file, 'w') as f:
json.dump(network_addresses, f, indent=2)
print(f'contracts deployed: {network_addresses}')
return addresses
def deploy(network, addresses_file):
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)
artifacts_path = ContractHandler.artifacts_path
if not addresses_file:
addresses_file = config.address_file
else:
addresses_file = Path(addresses_file).expanduser().resolve()
ocean = get_publisher_ocean_instance()
web3 = ocean.web3
addresses = dict()
if os.path.exists(addresses_file):
with open(addresses_file) as f:
network_addresses = json.load(f)
else:
network_addresses = {network: {}}
if network == "ganache" and network not in network_addresses:
network = "development"
_addresses = network_addresses[network]
# ****SET ENVT****
# grab vars
factory_deployer_private_key = get_ganache_wallet().private_key
# corner cases
if invalidKey(factory_deployer_private_key):
print("Need valid FACTORY_DEPLOYER_PRIVATE_KEY")
sys.exit(0)
# ****SEE FUNDS****
print("Keys:\n%s" % Wallet(
web3=get_web3(), private_key=factory_deployer_private_key).keysStr())
print("")
# ****DEPLOY****
deployer_wallet = Wallet(web3, private_key=factory_deployer_private_key)
minter_addr = deployer_wallet.address
# cap = 2 ** 255 not used
if DTFactory.CONTRACT_NAME not in _addresses:
print("****Deploy DataTokenTemplate: begin****")
dt_address = DataToken.deploy(
web3,
deployer_wallet,
artifacts_path,
"Template Contract",
"TEMPLATE",
minter_addr,
DataToken.DEFAULT_CAP_BASE,
DTFactory.FIRST_BLOB,
minter_addr,
)
addresses[DataToken.CONTRACT_NAME] = dt_address
print("****Deploy DataTokenTemplate: done****\n")
print("****Deploy DTFactory: begin****")
dtfactory = DTFactory(
DTFactory.deploy(web3, deployer_wallet, artifacts_path, dt_address,
minter_addr))
addresses[DTFactory.CONTRACT_NAME] = dtfactory.address
print("****Deploy DTFactory: done****\n")
if BFactory.CONTRACT_NAME not in _addresses:
print("****Deploy BPool: begin****")
bpool_address = BPool.deploy(web3, deployer_wallet, artifacts_path)
bpool_template = BPool(bpool_address)
addresses[BPool.CONTRACT_NAME] = bpool_address
print("****Deploy BPool: done****\n")
print("****Deploy 'BFactory': begin****")
bfactory_address = BFactory.deploy(web3, deployer_wallet,
artifacts_path,
bpool_template.address)
_ = BFactory(bfactory_address)
addresses[BFactory.CONTRACT_NAME] = bfactory_address
print("****Deploy 'BFactory': done****\n")
if FixedRateExchange.CONTRACT_NAME not in _addresses:
print("****Deploy 'FixedRateExchange': begin****")
addresses[FixedRateExchange.CONTRACT_NAME] = FixedRateExchange.deploy(
web3, deployer_wallet, artifacts_path)
print("****Deploy 'FixedRateExchange': done****\n")
if MetadataContract.CONTRACT_NAME not in _addresses:
print("****Deploy 'Metadata': begin****")
addresses[MetadataContract.CONTRACT_NAME] = MetadataContract.deploy(
web3, deployer_wallet, artifacts_path)
print("****Deploy 'Metadata': done****\n")
if network in ("ganache", "development"):
print("****Deploy fake OCEAN: begin****")
# For simplicity, hijack DataTokenTemplate.
minter_addr = deployer_wallet.address
OCEAN_cap = 1410 * 10**6 # 1.41B
OCEAN_cap_base = util.to_base_18(float(OCEAN_cap))
OCEAN_token = DataToken(
DataToken.deploy(
web3,
deployer_wallet,
artifacts_path,
"Ocean",
"OCEAN",
minter_addr,
OCEAN_cap_base,
"",
minter_addr,
))
addresses["Ocean"] = OCEAN_token.address
print("****Deploy fake OCEAN: done****\n")
print("****Mint fake OCEAN: begin****")
OCEAN_token.mint(minter_addr,
OCEAN_cap_base,
from_wallet=deployer_wallet)
print("****Mint fake OCEAN: done****\n")
print("****Distribute fake OCEAN: begin****")
amt_distribute = 1000
amt_distribute_base = util.to_base_18(float(amt_distribute))
for key_label in ["TEST_PRIVATE_KEY1", "TEST_PRIVATE_KEY2"]:
key = os.environ.get(key_label)
if not key:
continue
dst_address = privateKeyToAddress(key)
OCEAN_token.transfer(dst_address,
amt_distribute_base,
from_wallet=deployer_wallet)
print("****Distribute fake OCEAN: done****\n")
network_addresses[network].update(addresses)
with open(addresses_file, "w") as f:
json.dump(network_addresses, f, indent=2)
return addresses
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 ddo_registry(self) -> MetadataContract:
return MetadataContract(self._web3, self._metadata_registry_address)