def test_assets_consumed(publisher_instance, consumer_instance, ddo_sample):
acct = consumer_instance.main_account
consumed_assets = len(publisher_instance.assets.consumer_assets(acct.address))
asset = create_asset(publisher_instance, ddo_sample)
service = asset.get_service(service_type=ServiceTypes.ASSET_ACCESS)
service_dict = service.as_dictionary()
sa = ServiceAgreement.from_service_dict(service_dict)
keeper = publisher_instance.keeper
def grant_access(event, instance, agr_id, did, cons_address, account):
instance.agreements.conditions.grant_access(
agr_id, add_0x_prefix(did_to_id(did)), cons_address, account)
agreement_id = consumer_instance.assets.order(
asset.did, sa.index, acct, acct)
keeper.lock_payment_condition.subscribe_condition_fulfilled(
agreement_id,
15,
grant_access,
(publisher_instance, agreement_id, asset.did,
acct.address, publisher_instance.main_account),
wait=True
)
keeper.access_condition.subscribe_condition_fulfilled(
agreement_id,
15,
log_event(keeper.access_condition.FULFILLED_EVENT),
(),
wait=True
)
assert publisher_instance.agreements.is_access_granted(agreement_id, asset.did, acct.address)
assert len(publisher_instance.assets.consumer_assets(acct.address)) == consumed_assets + 1
publisher_instance.assets.retire(asset.did)
def test_agreement_hash(ddo_sample):
"""
This test verifies generating agreement hash using fixed inputs and ddo example.
This will make it easier to compare the hash generated from different languages.
"""
w3 = Web3
did = "did:nv:0c184915b07b44c888d468be85a9b28253e80070e5294b1aaed81c2f0264e430"
template_id = w3.toChecksumAddress(
"0x00bd138abd70e2f00903268f3db08f2d25677c9e")
agreement_id = '0xf136d6fadecb48fdb2fc1fb420f5a5d1c32d22d9424e47ab9461556e058fefaa'
sa = ServiceAgreement.from_service_dict(
ddo_sample.get_service(ServiceTypes.ASSET_ACCESS).as_dictionary())
sa.service_agreement_template.set_template_id(template_id)
assert template_id == sa.template_id, ''
assert did == ddo_sample.did
# Don't generate condition ids, use fixed ids so we get consistent hash
# (access_id, lock_id, escrow_id) = sa.generate_agreement_condition_ids(
# agreement_id, ddo.asset_id, consumer, publisher, keeper)
access_id = '0x2d7c1d60dc0c3f52aa9bd71ffdbe434a0e58435571e64c893bc9646fea7f6ec1'
lock_id = '0x1e265c434c14e668695dda1555088f0ea4356f596bdecb8058812e7dcba9ee73'
escrow_id = '0xe487fa6d435c2f09ef14b65b34521302f1532ac82ba8f6c86116acd8566e2da3'
print(f'condition ids: \n'
f'{access_id} \n'
f'{lock_id} \n'
f'{escrow_id}')
agreement_hash = ServiceAgreement.generate_service_agreement_hash(
sa.template_id, (access_id, lock_id, escrow_id),
sa.conditions_timelocks, sa.conditions_timeouts, agreement_id,
generate_multi_value_hash)
print('agreement hash: ', agreement_hash.hex())
expected = '0x96732b390dacec0f19ad304ac176b3407968a0184d01b3262687fd23a3f0995e'
print('expected hash: ', expected)
assert agreement_hash.hex() == expected, 'hash does not match.'
def _read_dict(self, dictionary):
"""Import a JSON dict into this DDO."""
values = dictionary
self._did = values['id']
self._created = values.get('created', None)
if 'publicKey' in values:
self._public_keys = []
for value in values['publicKey']:
if isinstance(value, str):
value = json.loads(value)
self._public_keys.append(
DDO.create_public_key_from_json(value))
if 'authentication' in values:
self._authentications = []
for value in values['authentication']:
if isinstance(value, str):
value = json.loads(value)
self._authentications.append(
DDO.create_authentication_from_json(value))
if 'service' in values:
self._services = []
for value in values['service']:
if isinstance(value, str):
value = json.loads(value)
if value['type'] == ServiceTypes.ASSET_ACCESS:
service = ServiceAgreement.from_service_dict(value)
elif value['type'] == ServiceTypes.ASSET_ACCESS_PROOF:
service = ServiceAgreement.from_service_dict(value)
elif value['type'] == ServiceTypes.CLOUD_COMPUTE:
service = ServiceAgreement.from_service_dict(value)
elif value['type'] == ServiceTypes.NFT_SALES:
service = ServiceAgreement.from_service_dict(value)
else:
service = Service.from_json(value)
self._services.append(service)
if 'proof' in values:
self._proof = values['proof']
def test_compute_logs(publisher_instance_no_init, consumer_instance_no_init,
metadata, algorithm_ddo, workflow_ddo):
consumer = publisher_instance_no_init.main_account
publisher = consumer_instance_no_init.main_account
# publish compute
ddo_computing = publisher_instance_no_init.assets.create_compute(
metadata, publisher)
# publish algorithm
metadata = algorithm_ddo['service'][0]
ddo_algorithm = consumer_instance_no_init.assets.create(
metadata['attributes'], consumer)
metadata = workflow_ddo['service'][0]
metadata['attributes']['main']['workflow']['stages'][0]['input'][0][
'id'] = ddo_computing.did
metadata['attributes']['main']['workflow']['stages'][0]['transformation'][
'id'] = ddo_algorithm.did
workflow_ddo = consumer_instance_no_init.assets.create(
metadata['attributes'], publisher)
assert workflow_ddo
# order compute asset
service = ddo_computing.get_service(
service_type=ServiceTypes.CLOUD_COMPUTE)
sa = ServiceAgreement.from_service_dict(service.as_dictionary())
agreement_id = consumer_instance_no_init.assets.order(
ddo_computing.did, sa.index, consumer, consumer)
keeper = Keeper.get_instance()
event = keeper.lock_payment_condition.subscribe_condition_fulfilled(
agreement_id, 60, None, (), wait=True)
assert event is not None, "Reward condition is not found"
# execute workflow
execution_id = consumer_instance_no_init.assets.execute(
agreement_id, ddo_computing.did, sa.index, consumer, workflow_ddo.did)
# get logs
logs = consumer_instance_no_init.assets.compute_logs(
agreement_id, execution_id, consumer)
assert logs
publisher_instance_no_init.assets.retire(ddo_computing.did)
publisher_instance_no_init.assets.retire(ddo_algorithm.did)
publisher_instance_no_init.assets.retire(workflow_ddo.did)
def demo():
"""The Nevermined Federated Learning demo.
This demo showcases the nevermined Federated Learning capabilities.
FLow:
1. Setup nevermined
2. Setup accounts
3. Publish compute to the data assets
4. Publish algorithm
5. Publish workflows
6. Order computations
7. Execute workflows
"""
print("Setting up...\n")
date_created = dates_generator()
# 1. Setup nevermined
nevermined = Nevermined(Config("config.ini"))
keeper = Keeper.get_instance()
provider = "0x068Ed00cF0441e4829D9784fCBe7b9e26D4BD8d0"
# 2. Setup accounts
acc = Account(Web3.toChecksumAddress(PARITY_ADDRESS), PARITY_PASSWORD,
PARITY_KEYFILE)
nevermined.accounts.request_tokens(acc, 100)
provider_data0 = acc
provider_data1 = acc
provider_coordinator = acc
consumer = acc
# 3. Publish compute to the data
with open("resources/metadata/metadata0.json") as f:
metadata_data0 = json.load(f)
metadata_data0["main"]["dateCreated"] = next(date_created)
with open("resources/metadata/metadata1.json") as f:
metadata_data1 = json.load(f)
metadata_data1["main"]["dateCreated"] = next(date_created)
ddo_compute0 = nevermined.assets.create_compute(
metadata_data0,
provider_data0,
providers=[provider],
)
assert ddo_compute0 is not None, "Creating asset compute0 on-chain failed"
print(
f"[DATA_PROVIDER0 --> NEVERMINED] Publishing compute to the data asset for asset0: {ddo_compute0.did}"
)
ddo_compute1 = nevermined.assets.create_compute(
metadata_data1,
provider_data1,
providers=[provider],
)
assert ddo_compute1 is not None, "Creating asset compute1 on-chain failed"
print(
f"[DATA_PROVIDER1 --> NEVERMINED] Publishing compute to the data asset for asset1: {ddo_compute1.did}"
)
with open("resources/metadata/metadata_compute_coordinator.json") as f:
metadata_compute_coordinator = json.load(f)
metadata_compute_coordinator["main"]["dateCreated"] = next(
date_created)
ddo_compute_coordinator = nevermined.assets.create_compute(
metadata_compute_coordinator,
provider_coordinator,
providers=[provider],
)
assert (ddo_compute_coordinator
is not None), "Creating asset compute_coordinator on-chain failed"
print(
f"[COORDINATOR_PROVIDER --> NEVERMINED] Publishing coordinator compute asset: {ddo_compute_coordinator.did}"
)
# 4. Publish algorithm
with open("resources/metadata/metadata_transformation.json") as f:
metadata_transformation = json.load(f)
metadata_transformation["main"]["dateCreated"] = next(date_created)
ddo_transformation = nevermined.assets.create(
metadata_transformation,
consumer,
providers=[provider],
)
assert (ddo_transformation
is not None), "Creating asset transformation on-chain failed"
print(
f"[DATA_SCIENTIST --> NEVERMINED] Publishing algorithm asset: {ddo_transformation.did}"
)
# 5. Publish the workflows
with open("resources/metadata/metadata_workflow.json") as f:
metadata_workflow = json.load(f)
with open("resources/metadata/metadata_workflow_coordinator.json") as f:
metadata_workflow_coordinator = json.load(f)
metadata_workflow0 = copy.deepcopy(metadata_workflow)
metadata_workflow0["main"]["workflow"]["stages"][0]["input"][0][
"id"] = ddo_compute0.did
metadata_workflow0["main"]["workflow"]["stages"][0]["transformation"][
"id"] = ddo_transformation.did
metadata_workflow1 = copy.deepcopy(metadata_workflow)
metadata_workflow1["main"]["workflow"]["stages"][0]["input"][0][
"id"] = ddo_compute1.did
metadata_workflow1["main"]["workflow"]["stages"][0]["transformation"][
"id"] = ddo_transformation.did
metadata_workflow_coordinator["main"]["dateCreated"] = next(date_created)
ddo_workflow0 = nevermined.assets.create(
metadata_workflow0,
consumer,
providers=[provider],
)
assert ddo_workflow0 is not None, "Creating asset workflow0 on-chain failed"
print(
f"[DATA_SCIENTIST --> NEVERMINED] Publishing compute workflow for asset0: {ddo_workflow0.did}"
)
ddo_workflow1 = nevermined.assets.create(
metadata_workflow1,
consumer,
providers=[provider],
)
assert ddo_workflow1 is not None, "Creating asset workflow1 on-chain failed"
print(
f"[DATA_SCIENTIST --> NEVERMINED] Publishing compute workflow for asset1: {ddo_workflow1.did}"
)
ddo_workflow_coordinator = nevermined.assets.create(
metadata_workflow_coordinator,
consumer,
providers=[provider],
)
assert (ddo_workflow_coordinator
is not None), "Creating asset workflow_coordinator on-chain failed"
print(
f"[DATA_SCIENTIST --> NEVERMINED] Publishing compute workflow for coordinator: {ddo_workflow_coordinator.did}"
)
# 6. Order computations
service0 = ddo_compute0.get_service(
service_type=ServiceTypes.CLOUD_COMPUTE)
service_agreement0 = ServiceAgreement.from_service_dict(
service0.as_dictionary())
agreement_id0 = nevermined.assets.order(ddo_compute0.did,
service_agreement0.index, consumer,
consumer)
print(
f"[DATA_SCIENTIST --> DATA_PROVIDER0] Requesting an agreement for compute to the data for asset0: {agreement_id0}"
)
event = keeper.lock_reward_condition.subscribe_condition_fulfilled(
agreement_id0, 60, None, (), wait=True)
assert event is not None, "Reward condition is not found"
event = keeper.compute_execution_condition.subscribe_condition_fulfilled(
agreement_id0, 60, None, (), wait=True)
assert event is not None, "Execution condition not found"
service1 = ddo_compute1.get_service(
service_type=ServiceTypes.CLOUD_COMPUTE)
service_agreement1 = ServiceAgreement.from_service_dict(
service1.as_dictionary())
agreement_id1 = nevermined.assets.order(ddo_compute1.did,
service_agreement1.index, consumer,
consumer)
print(
f"[DATA_SCIENTIST --> DATA_PROVIDER1] Requesting an agreement for compute to the data for asset1: {agreement_id1}"
)
event = keeper.lock_reward_condition.subscribe_condition_fulfilled(
agreement_id1, 60, None, (), wait=True)
assert event is not None, "Reward condition is not found"
event = keeper.compute_execution_condition.subscribe_condition_fulfilled(
agreement_id1, 60, None, (), wait=True)
assert event is not None, "Execution condition not found"
service_coordinator = ddo_compute_coordinator.get_service(
service_type=ServiceTypes.CLOUD_COMPUTE)
service_agreement_coordinator = ServiceAgreement.from_service_dict(
service_coordinator.as_dictionary())
agreement_id_coordinator = nevermined.assets.order(
ddo_compute_coordinator.did, service_agreement_coordinator.index,
consumer, consumer)
print(
f"[DATA_SCIENTIST --> COORDINATOR_PROVIDER] Requesting an agreement for coordinator compute: {agreement_id_coordinator}"
)
event = keeper.lock_reward_condition.subscribe_condition_fulfilled(
agreement_id_coordinator, 60, None, (), wait=True)
assert event is not None, "Reward condition is not found"
event = keeper.compute_execution_condition.subscribe_condition_fulfilled(
agreement_id_coordinator, 60, None, (), wait=True)
assert event is not None, "Execution condition not found"
# 7. Execute workflows
compute_coordinator_id = nevermined.assets.execute(
agreement_id_coordinator,
ddo_compute_coordinator.did,
service_agreement_coordinator.index,
consumer,
ddo_workflow_coordinator.did,
)
print(
f"[DATA_SCIENTIST --> COORDINATOR_PROVIDER] Requesting execution for coordinator compute: {compute_coordinator_id}"
)
compute_asset0_id = nevermined.assets.execute(
agreement_id0,
ddo_compute0.did,
service_agreement0.index,
consumer,
ddo_workflow0.did,
)
print(
f"[DATA_SCIENTIST --> DATA_PROVIDER0] Requesting execution for compute to data for asset0: {compute_asset0_id}"
)
compute_asset1_id = nevermined.assets.execute(
agreement_id1,
ddo_compute1.did,
service_agreement1.index,
consumer,
ddo_workflow1.did,
)
print(
f"[DATA_SCIENTIST --> DATA_PROVIDER1] Requesting execution for compute to data for asset1: {compute_asset1_id}"
)
jobs = [
(agreement_id_coordinator, compute_coordinator_id),
(agreement_id0, compute_asset0_id),
(agreement_id1, compute_asset1_id),
]
return jobs
def test_buy_asset(publisher_instance_no_init, consumer_instance_no_init):
config = ExampleConfig.get_config()
ConfigProvider.set_config(config)
keeper = Keeper.get_instance()
# :TODO: enable the actual SecretStore
# SecretStoreProvider.set_secret_store_class(SecretStore)
w3 = Web3Provider.get_web3()
pub_acc = get_publisher_account()
# Register ddo
ddo = get_registered_ddo(publisher_instance_no_init, pub_acc)
assert isinstance(ddo, DDO)
# nevermined here will be used only to publish the asset. Handling the asset by the publisher
# will be performed by the Gateway server running locally
# restore the http client because we want the actual Gateway server to do the work
# not the GatewayMock.
# Gateway.set_http_client(requests)
consumer_account = get_consumer_account()
downloads_path_elements = len(
os.listdir(consumer_instance_no_init._config.downloads_path)) if os.path.exists(
consumer_instance_no_init._config.downloads_path) else 0
# sign agreement using the registered asset did above
service = ddo.get_service(service_type=ServiceTypes.ASSET_ACCESS)
sa = ServiceAgreement.from_service_dict(service.as_dictionary())
# This will send the access request to Gateway which in turn will execute the agreement on-chain
consumer_instance_no_init.accounts.request_tokens(consumer_account, 100)
agreement_id = consumer_instance_no_init.assets.order(
ddo.did, sa.index, consumer_account, consumer_account)
event_wait_time = 10
event = keeper.lock_payment_condition.subscribe_condition_fulfilled(
agreement_id,
event_wait_time,
log_event(keeper.lock_payment_condition.FULFILLED_EVENT),
(),
wait=True
)
assert event, 'no event for LockRewardCondition.Fulfilled'
# give access
publisher_instance_no_init.agreements.conditions.grant_access(
agreement_id, ddo.asset_id, consumer_account.address, pub_acc)
event = keeper.access_condition.subscribe_condition_fulfilled(
agreement_id,
event_wait_time,
log_event(keeper.access_condition.FULFILLED_EVENT),
(),
wait=True
)
assert event, 'no event for AccessSecretStoreCondition.Fulfilled'
assert consumer_instance_no_init.agreements.is_access_granted(agreement_id, ddo.did, consumer_account.address)
amounts = list(map(int, service.get_param_value_by_name('_amounts')))
receivers = service.get_param_value_by_name('_receivers')
publisher_instance_no_init.agreements.conditions.release_reward(
agreement_id, ddo.asset_id, amounts, receivers, pub_acc)
assert consumer_instance_no_init.assets.access(
agreement_id,
ddo.did,
sa.index,
consumer_account,
config.downloads_path)
assert len(os.listdir(config.downloads_path)) == downloads_path_elements + 1
# Check that we can access only an specific file in passing the index.
assert consumer_instance_no_init.assets.access(
agreement_id,
ddo.did,
sa.index,
consumer_account,
config.downloads_path,
1
)
assert len(os.listdir(config.downloads_path)) == downloads_path_elements + 1
with pytest.raises(AssertionError):
consumer_instance_no_init.assets.access(
agreement_id,
ddo.did,
sa.index,
consumer_account,
config.downloads_path,
-2
)
with pytest.raises(AssertionError):
consumer_instance_no_init.assets.access(
agreement_id,
ddo.did,
sa.index,
consumer_account,
config.downloads_path,
3
)
# decrypt the contentUrls using the publisher account instead of consumer account.
# if the secret store is working and ACL check is enabled, this should fail
# since SecretStore decrypt will fail the checkPermissions check and the gateway will return
# an http error code back
with pytest.raises(ValueError) as e:
consumer_instance_no_init.assets.access(
agreement_id,
ddo.did,
sa.index,
pub_acc,
config.downloads_path
)
print(e)
def test_buy_asset_no_secret_store(publisher_instance_gateway, consumer_instance_gateway):
config = ExampleConfig.get_config()
ConfigProvider.set_config(config)
keeper = Keeper.get_instance()
w3 = Web3Provider.get_web3()
pub_acc = get_publisher_account()
for method in [ServiceAuthorizationTypes.SECRET_STORE, ServiceAuthorizationTypes.PSK_ECDSA, ServiceAuthorizationTypes.PSK_RSA]:
# Register ddo
ddo = get_registered_with_psk(publisher_instance_gateway, pub_acc, auth_method=method)
assert isinstance(ddo, DDO)
# nevermined here will be used only to publish the asset. Handling the asset by the publisher
# will be performed by the Gateway server running locally
# restore the http client because we want the actual Gateway server to do the work
# not the GatewayMock.
# Gateway.set_http_client(requests)
consumer_account = get_consumer_account()
downloads_path_elements = len(
os.listdir(consumer_instance_gateway._config.downloads_path)) if os.path.exists(
consumer_instance_gateway._config.downloads_path) else 0
# sign agreement using the registered asset did above
service = ddo.get_service(service_type=ServiceTypes.ASSET_ACCESS)
sa = ServiceAgreement.from_service_dict(service.as_dictionary())
# This will send the access request to Gateway which in turn will execute the agreement on-chain
consumer_instance_gateway.accounts.request_tokens(consumer_account, 100)
agreement_id = consumer_instance_gateway.assets.order(
ddo.did, sa.index, consumer_account, consumer_account)
event_wait_time = 10
event = keeper.access_template.subscribe_agreement_created(
agreement_id,
event_wait_time,
log_event(keeper.access_template.AGREEMENT_CREATED_EVENT),
(),
wait=True
)
assert event, 'no event for EscrowAccessSecretStoreTemplate.AgreementCreated'
event = keeper.lock_payment_condition.subscribe_condition_fulfilled(
agreement_id,
event_wait_time,
log_event(keeper.lock_payment_condition.FULFILLED_EVENT),
(),
wait=True
)
assert event, 'no event for LockRewardCondition.Fulfilled'
# give access
publisher_instance_gateway.agreements.conditions.grant_access(
agreement_id, ddo.asset_id, consumer_account.address, pub_acc)
event = keeper.access_condition.subscribe_condition_fulfilled(
agreement_id,
event_wait_time,
log_event(keeper.access_condition.FULFILLED_EVENT),
(),
wait=True
)
assert event, 'no event for AccessSecretStoreCondition.Fulfilled'
assert consumer_instance_gateway.agreements.is_access_granted(agreement_id, ddo.did, consumer_account.address)
publisher_instance_gateway.agreements.conditions.release_reward(
agreement_id, ddo.asset_id, sa.get_amounts_int(), sa.get_receivers(), pub_acc)
assert consumer_instance_gateway.assets.access(
agreement_id,
ddo.did,
sa.index,
consumer_account,
config.downloads_path)
assert len(os.listdir(config.downloads_path)) == downloads_path_elements + 1
with pytest.raises(AssertionError):
consumer_instance_gateway.assets.access(
agreement_id,
ddo.did,
sa.index,
consumer_account,
config.downloads_path,
-2
)
with pytest.raises(AssertionError):
consumer_instance_gateway.assets.access(
agreement_id,
ddo.did,
sa.index,
consumer_account,
config.downloads_path,
3
)
def test_nfts_flow(publisher_instance_no_init, consumer_instance_no_init):
config = ExampleConfig.get_config()
ConfigProvider.set_config(config)
keeper = Keeper.get_instance()
pub_acc = get_publisher_account()
# Register ddo
ddo = get_registered_ddo_nft(publisher_instance_no_init, pub_acc)
asset_id = ddo.asset_id
nft_amounts = 1
assert isinstance(ddo, DDO)
consumer_account = get_consumer_account()
consumer_instance_no_init.accounts.request_tokens(consumer_account, 100)
service_sales = ddo.get_service(service_type=ServiceTypes.NFT_SALES)
sa_sales = ServiceAgreement.from_service_dict(
service_sales.as_dictionary())
amounts = sa_sales.get_amounts_int()
receivers = sa_sales.get_receivers()
number_nfts = sa_sales.get_number_nfts()
token_address = keeper.token.address
sales_agreement_id = consumer_instance_no_init.assets.order(
ddo.did, sa_sales.index, consumer_account, consumer_account)
sales_agreement = keeper.agreement_manager.get_agreement(
sales_agreement_id)
assert sales_agreement.did == asset_id, ''
lock_cond_id = sales_agreement.condition_ids[0]
access_cond_id = sales_agreement.condition_ids[1]
escrow_cond_id = sales_agreement.condition_ids[2]
# transfer the nft
keeper.transfer_nft_condition.fulfill(sales_agreement_id, asset_id,
consumer_account.address,
nft_amounts, lock_cond_id, pub_acc)
# escrow payment
keeper.escrow_payment_condition.fulfill(
sales_agreement_id, asset_id, amounts, receivers,
keeper.escrow_payment_condition.address, token_address, lock_cond_id,
access_cond_id, pub_acc)
assert keeper.condition_manager.get_condition_state(lock_cond_id) == 2, ''
assert keeper.condition_manager.get_condition_state(
access_cond_id) == 2, ''
assert keeper.condition_manager.get_condition_state(
escrow_cond_id) == 2, ''
assert keeper.did_registry.balance(consumer_account.address,
asset_id) >= number_nfts
# CHECK ACCESS CREATING THE AGREEMENT
nft_access_service_agreement = ServiceAgreement.from_ddo(
ServiceTypes.NFT_ACCESS, ddo)
sa_access = ddo.get_service(service_type=ServiceTypes.NFT_ACCESS)
nft_access_agreement_id = consumer_instance_no_init.assets.order(
ddo.did, sa_access.index, consumer_account, consumer_account)
event = keeper.nft_access_template.subscribe_agreement_created(
nft_access_agreement_id,
10,
log_event(keeper.nft_access_template.AGREEMENT_CREATED_EVENT), (),
wait=True)
assert event, 'no event for AgreementCreated '
time.sleep(3)
keeper.nft_holder_condition.fulfill(nft_access_agreement_id, asset_id,
consumer_account.address, number_nfts,
consumer_account)
time.sleep(3)
keeper.nft_access_condition.fulfill(nft_access_agreement_id, asset_id,
consumer_account.address, pub_acc)
time.sleep(3)
access_agreement = keeper.agreement_manager.get_agreement(
nft_access_agreement_id)
assert access_agreement.did == asset_id, ''
nft_holder_cond_id = access_agreement.condition_ids[0]
nft_access_cond_id = access_agreement.condition_ids[1]
assert keeper.condition_manager.get_condition_state(
nft_access_cond_id) == 2, ''
assert keeper.condition_manager.get_condition_state(
nft_holder_cond_id) == 2, ''
# AND HERE TESTING WITHOUT CREATING THE AGREEMENT
service_access = ddo.get_service(service_type=ServiceTypes.NFT_ACCESS)
no_agreement_id = '0x'
assert consumer_instance_no_init.assets.access(
no_agreement_id,
ddo.did,
service_access.index,
consumer_account,
config.downloads_path,
service_type=ServiceTypes.NFT_ACCESS)
# AND HERE CHECKING CREATING AN AGREEMENT FIRST
nft_access_service_agreement = ServiceAgreement.from_ddo(
ServiceTypes.NFT_ACCESS, ddo)
nft_access_agreement_id = ServiceAgreement.create_new_agreement_id()
(nft_access_cond_id, nft_holder_cond_id
) = nft_access_service_agreement.generate_agreement_condition_ids(
nft_access_agreement_id, asset_id, consumer_account.address, keeper)
keeper.nft_access_template.create_agreement(
nft_access_agreement_id, asset_id,
[nft_holder_cond_id, nft_access_cond_id],
nft_access_service_agreement.conditions_timelocks,
nft_access_service_agreement.conditions_timeouts,
consumer_account.address, pub_acc)
event = keeper.nft_access_template.subscribe_agreement_created(
nft_access_agreement_id,
10,
log_event(keeper.nft_access_template.AGREEMENT_CREATED_EVENT), (),
wait=True)
assert event, 'no event for AgreementCreated '
# This is because in this test the gateway is executed using the same account than the consumer
keeper.did_registry.add_provider(asset_id, consumer_account.address,
pub_acc)
time.sleep(3)
assert consumer_instance_no_init.assets.access(
nft_access_agreement_id,
ddo.did,
service_access.index,
consumer_account,
config.downloads_path,
index=0,
service_type=ServiceTypes.NFT_ACCESS)
def compute_example(verbose=False):
print("Setting up...")
if verbose:
configure_logging()
date_created = dates_generator()
# Setup nevermined
ConfigProvider.set_config(ExampleConfig.get_config())
config = ConfigProvider.get_config()
nevermined = Nevermined()
keeper = Keeper.get_instance()
provider = "0x068Ed00cF0441e4829D9784fCBe7b9e26D4BD8d0"
asset_rewards = {
"_amounts": ["10", "2"],
"_receivers": ["0x00Bd138aBD70e2F00903268F3Db08f2D25677C9e", "0x068ed00cf0441e4829d9784fcbe7b9e26d4bd8d0"]
}
# Setup accounts
acc = Account(
Web3.toChecksumAddress(PROVIDER_ADDRESS), PROVIDER_PASSWORD, PROVIDER_KEYFILE
)
nevermined.accounts.request_tokens(acc, 10)
provider_acc = acc
consumer_acc = acc
# Publish compute
example_metadata.compute_ddo["main"]["dateCreated"] = next(date_created)
ddo_compute = nevermined.assets.create_compute(
example_metadata.metadata, provider_acc, asset_rewards, providers=[provider]
)
assert ddo_compute is not None, "Creating compute asset on-chain failed."
print(
f"[PROVIDER --> NEVERMINED] Publishing compute to the data asset: {ddo_compute.did}"
)
# Publish algorithm
example_metadata.algo_metadata["main"]["dateCreated"] = next(date_created)
ddo_transformation = nevermined.assets.create(
example_metadata.algo_metadata, consumer_acc, providers=[provider]
)
assert (
ddo_transformation is not None
), "Creating asset transformation on-chain failed."
print(
f"[CONSUMER --> NEVERMINED] Publishing algorithm asset: {ddo_transformation.did}"
)
# Publish workflows
workflow_metadata = example_metadata.workflow_ddo
workflow_metadata["main"]["workflow"]["stages"][0]["input"][0]["id"] = ddo_compute.did
workflow_metadata["main"]["workflow"]["stages"][0]["transformation"][
"id"
] = ddo_transformation.did
ddo_workflow = nevermined.assets.create(
workflow_metadata, consumer_acc, providers=[provider]
)
assert ddo_workflow is not None, "Creating asset workflow on-chain failed."
print(f"[CONSUMER --> NEVERMINED] Publishing compute workflow: {ddo_workflow.did}")
# Order computation
service = ddo_compute.get_service(service_type=ServiceTypes.CLOUD_COMPUTE)
service_agreement = ServiceAgreement.from_service_dict(service.as_dictionary())
agreement_id = nevermined.assets.order(
ddo_compute.did, service_agreement.index, consumer_acc
)
print(
f"[CONSUMER --> PROVIDER] Requesting an agreement for compute to the data: {agreement_id}"
)
event = keeper.lock_payment_condition.subscribe_condition_fulfilled(
agreement_id, 60, None, (), wait=True
)
assert event is not None, "Reward condition is not found"
event = keeper.compute_execution_condition.subscribe_condition_fulfilled(
agreement_id, 60, None, (), wait=True
)
assert event is not None, "Execution condition not found"
# Execute workflow
nevermined.assets.execute(
agreement_id,
ddo_compute.did,
service_agreement.index,
consumer_acc,
ddo_workflow.did,
)
print("[CONSUMER --> PROVIDER] Requesting execution of the compute workflow")
event = keeper.escrow_payment_condition.subscribe_condition_fulfilled(
agreement_id, 60, None, (), wait=True
)
assert event is not None, "Escrow Reward condition not found"
print("Workflow successfully executed")
def buy_asset():
"""
Requires all Nevermined services running.
"""
ConfigProvider.set_config(ExampleConfig.get_config())
config = ConfigProvider.get_config()
providers = {
'duero': '0xfEF2d5e1670342b9EF22eeeDcb287EC526B48095',
'nile': '0x4aaab179035dc57b35e2ce066919048686f82972'
}
# make nevermined instance
nevermined = Nevermined()
Diagnostics.verify_contracts()
acc = get_account(1)
if not acc:
acc = ([acc for acc in nevermined.accounts.list() if acc.password] or nevermined.accounts.list())[0]
keeper = Keeper.get_instance()
# Register ddo
did = '' # 'did:nv:7648596b60f74301ae1ef9baa5d637255d517ff362434754a3779e1de4c8219b'
if did:
ddo = nevermined.assets.resolve(did)
logging.info(f'using ddo: {did}')
else:
ddo = nevermined.assets.create(example_metadata.metadata, acc, providers=[], authorization_type='SecretStore', use_secret_store=True)
assert ddo is not None, f'Registering asset on-chain failed.'
did = ddo.did
logging.info(f'registered ddo: {did}')
# nevermined here will be used only to publish the asset. Handling the asset by the publisher
# will be performed by the Gateway server running locally
test_net = os.environ.get('TEST_NET', '')
if test_net.startswith('nile'):
provider = keeper.did_registry.to_checksum_address(providers['nile'])
elif test_net.startswith('duero'):
provider = keeper.did_registry.to_checksum_address(providers['duero'])
else:
provider = '0x068Ed00cF0441e4829D9784fCBe7b9e26D4BD8d0'
# Wait for did registry event
event = keeper.did_registry.subscribe_to_event(
keeper.did_registry.DID_REGISTRY_EVENT_NAME,
30,
event_filter={
'_did': Web3Provider.get_web3().toBytes(hexstr=ddo.asset_id),
'_owner': acc.address},
wait=True
)
if not event:
logging.warning(f'Failed to get the did registry event for asset with did {did}.')
assert keeper.did_registry.get_block_number_updated(ddo.asset_id) > 0, \
f'There is an issue in registering asset {did} on-chain.'
keeper.did_registry.add_provider(ddo.asset_id, provider, acc)
logging.info(f'is {provider} set as did provider: '
f'{keeper.did_registry.is_did_provider(ddo.asset_id, provider)}')
nevermined_cons = Nevermined()
consumer_account = get_account(0)
# sign agreement using the registered asset did above
service = ddo.get_service(service_type=ServiceTypes.ASSET_ACCESS)
# This will send the order request to Gateway which in turn will execute the agreement on-chain
nevermined_cons.accounts.request_tokens(consumer_account, 10)
sa = ServiceAgreement.from_service_dict(service.as_dictionary())
agreement_id = ''
if not agreement_id:
# Use these 2 lines to request new agreement from Gateway
# agreement_id, signature = nevermined_cons.agreements.prepare(did, sa.service_definition_id,
# consumer_account)
# nevermined_cons.agreements.send(did, agreement_id, sa.service_definition_id, signature,
# consumer_account)
# assets.order now creates agreement directly using consumer account.
agreement_id = nevermined_cons.assets.order(
did, sa.index, consumer_account)
logging.info('placed order: %s, %s', did, agreement_id)
event = keeper.access_template.subscribe_agreement_created(
agreement_id, 60, None, (), wait=True
)
assert event, "Agreement event is not found, check the keeper node's logs"
logging.info(f'Got agreement event, next: lock reward condition')
event = keeper.lock_payment_condition.subscribe_condition_fulfilled(
agreement_id, 60, None, (), wait=True
)
assert event, "Lock reward condition fulfilled event is not found, check the keeper node's logs"
logging.info('Got lock reward event, next: wait for the access condition..')
event = keeper.access_condition.subscribe_condition_fulfilled(
agreement_id, 15, None, (), wait=True
)
logging.info(f'Got access event {event}')
i = 0
while nevermined.agreements.is_access_granted(
agreement_id, did, consumer_account.address) is not True and i < 15:
time.sleep(1)
i += 1
assert nevermined.agreements.is_access_granted(agreement_id, did, consumer_account.address)
nevermined.assets.access(
agreement_id,
did,
sa.index,
consumer_account,
config.downloads_path,
index=0)
logging.info('Success buying asset.')
event = keeper.escrow_payment_condition.subscribe_condition_fulfilled(
agreement_id,
30,
None,
(),
wait=True
)
assert event, 'no event for EscrowReward.Fulfilled'
logging.info(f'got EscrowReward.FULFILLED event: {event}')
logging.info('Done buy asset.')
