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.')