Using last versions to fix the NFTs flow

nevermined_sdk_py/nevermined/assets.py

@@ -159,7 +159,11 @@ def create(self, metadata, publisher_account,
         ddo.add_proof(checksums, publisher_account)
 
         # Generating the did and adding to the ddo.
-        did = ddo.assign_did(DID.did(ddo.proof['checksum']))
+        did_seed = checksum(ddo.proof['checksum'])
+        asset_id = self._keeper.did_registry.hash_did(did_seed, publisher_account.address)
+        ddo._did = DID.did(asset_id)
+        did = ddo._did
+
         logger.debug(f'Generating new did: {did}')
         # Check if it's already registered first!
         if did in self._get_metadata_provider().list_assets():
@@ -263,7 +267,7 @@ def create(self, metadata, publisher_account,
         # register on-chain
         if mint > 0 or royalties is not None or cap is not None:
             registered_on_chain = self._keeper.did_registry.register_mintable_did(
-                ddo.asset_id,
+                did_seed,
                 checksum=Web3Provider.get_web3().toBytes(hexstr=ddo.asset_id),
                 url=ddo_service_endpoint,
                 account=publisher_account,
@@ -277,7 +281,7 @@ def create(self, metadata, publisher_account,
                 self._keeper.did_registry.mint(ddo.asset_id, mint, account=publisher_account)
         else:
             registered_on_chain = self._keeper.did_registry.register(
-                ddo.asset_id,
+                did_seed,
                 checksum=Web3Provider.get_web3().toBytes(hexstr=ddo.asset_id),
                 url=ddo_service_endpoint,
                 account=publisher_account,
@@ -305,8 +309,8 @@ def create(self, metadata, publisher_account,
         return ddo
 
     def create_compute(self, metadata, publisher_account, asset_rewards={"_amounts": [], "_receivers": []},
-               service_descriptors=None, providers=None,
-               authorization_type=ServiceAuthorizationTypes.PSK_RSA, use_secret_store=False):
+                       service_descriptors=None, providers=None,
+                       authorization_type=ServiceAuthorizationTypes.PSK_RSA, use_secret_store=False):
         """
         Register a compute to the data asset in both the keeper's DIDRegistry (on-chain) and in
         the Metadata store.
@@ -335,8 +339,8 @@ def create_compute(self, metadata, publisher_account, asset_rewards={"_amounts":
             compute_service_attributes, gateway.get_execute_endpoint(self._config))
 
         return self.create(metadata, publisher_account, service_descriptors=[service_descriptor],
-            providers=providers, authorization_type=authorization_type,
-            use_secret_store=use_secret_store)
+                           providers=providers, authorization_type=authorization_type,
+                           use_secret_store=use_secret_store)
 
     def retire(self, did):
         """

scripts/wait_for_migration_and_extract_keeper_artifacts.sh

@@ -3,6 +3,7 @@
 RETRY_COUNT=0
 COMMAND_STATUS=1
 
+rm -rf artifacts
 mkdir -p artifacts
 
 until [ $COMMAND_STATUS -eq 0 ] || [ $RETRY_COUNT -eq 120 ]; do

setup.py

@@ -20,8 +20,8 @@
     'pyopenssl',
     'PyJWT',  # not jwt
     'PyYAML>=5.2',
-    'common-utils-py==0.7.0',
-    'contracts-lib-py==0.7.1',
+    'common-utils-py==0.7.1',
+    'contracts-lib-py==0.7.4',
     'nevermined-secret-store==0.1.1',
     'requests>=2.21.0',
     'deprecated',

tests/conftest.py

@@ -88,7 +88,7 @@ def asset1():
     asset = _get_asset(
         'https://raw.githubusercontent.com/nevermined-io/docs/master/docs/architecture/specs'
         '/examples/access/v0.1/ddo1.json')
-    asset._did = DID.did(asset.proof['checksum'])
+    asset._did = DID.encoded_did(asset.proof['checksum'])
     yield asset
     metadata_provider.retire_all_assets()
 
@@ -98,7 +98,7 @@ def asset2():
     asset = _get_asset(
         'https://raw.githubusercontent.com/nevermined-io/docs/master/docs/architecture/specs'
         '/examples/access/v0.1/ddo2-update.json')
-    asset._did = DID.did(asset.proof['checksum'])
+    asset._did = DID.encoded_did(asset.proof['checksum'])
     return asset
 
 
@@ -151,18 +151,18 @@ def setup_agreements_environment(ddo_sample):
     keeper = Keeper.get_instance()
 
     ddo = ddo_sample
-    ddo._did = DID.did({"0": generate_prefixed_id()})
+    did_seed = generate_prefixed_id()
+    asset_id = keeper.did_registry.hash_did(did_seed, publisher_acc.address)
+    ddo._did = DID.did(asset_id)
 
     keeper.did_registry.register(
-        ddo.asset_id,
+        did_seed,
         checksum=Web3Provider.get_web3().toBytes(hexstr=ddo.asset_id),
         url='localhost:5000',
         account=publisher_acc,
         providers=None
     )
 
-    registered_ddo = ddo
-    asset_id = registered_ddo.asset_id
     service_agreement = ServiceAgreement.from_ddo(ServiceTypes.ASSET_ACCESS, ddo)
     agreement_id = ServiceAgreement.create_new_agreement_id()
     price = service_agreement.get_price()

tests/nevermined/test_assets.py

@@ -71,7 +71,7 @@ def test_resolve_did(publisher_instance, metadata):
     assert ddo['service'][1] == original['service'][1]
 
     # Can't resolve unregistered asset
-    unregistered_did = DID.did({"0": "0x00112233445566"})
+    unregistered_did = DID.encoded_did({"0": "0x00112233445566"})
     with pytest.raises(DIDNotFound):
         publisher_instance.assets.resolve(unregistered_did)
 

tests/nevermined/test_nfts.py

@@ -1,14 +1,11 @@
-import os
+import time
 
-import pytest
 from common_utils_py.agreements.service_agreement import ServiceAgreement
 from common_utils_py.agreements.service_types import ServiceTypes
 from common_utils_py.ddo.ddo import DDO
-from common_utils_py.oauth2.token import generate_access_grant_token
 
 from examples import ExampleConfig
 from nevermined_sdk_py import ConfigProvider
-from nevermined_sdk_py.nevermined.agreements import check_token_address
 from nevermined_sdk_py.nevermined.keeper import NeverminedKeeper as Keeper
 from tests.resources.helper_functions import (get_consumer_account, get_publisher_account,
                                               log_event, get_registered_ddo_nft)
@@ -30,11 +27,6 @@ def test_nfts_flow(publisher_instance_no_init, consumer_instance_no_init):
     consumer_account = get_consumer_account()
 
     consumer_instance_no_init.accounts.request_tokens(consumer_account, 100)
-    # assets.transfer_nft(asset_id, consumer_account.address, nft_amounts, pub_acc)
-    # assert assets.balance(consumer_account.address, asset_id) >= nft_amounts
-
-    # nft_sales_sa = ServiceAgreement.from_ddo(ServiceTypes.NFT_SALES, ddo)
-    # nft_access_sa = ServiceAgreement.from_ddo(ServiceTypes.NFT_ACCESS, ddo)
 
     service_sales = ddo.get_service(service_type=ServiceTypes.NFT_SALES)
     sa_sales = ServiceAgreement.from_service_dict(service_sales.as_dictionary())
@@ -83,11 +75,70 @@ def test_nfts_flow(publisher_instance_no_init, consumer_instance_no_init):
 
     assert keeper.did_registry.balance(consumer_account.address, asset_id) >= number_nfts
 
-    # check access without agreement
+
+    # 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)
+
+    # 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 '
+
+    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)
-    # assert consumer_instance_no_init.assets.access('0x', ddo.did, service_access.index, consumer_account,
-    #                                                config.downloads_path, 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(
@@ -112,60 +163,16 @@ def test_nfts_flow(publisher_instance_no_init, consumer_instance_no_init):
     )
     assert event, 'no event for AgreementCreated '
 
-    keeper.nft_holder_condition.fulfill(
-        nft_access_agreement_id, asset_id, consumer_account.address, number_nfts, pub_acc
-    )
-    keeper.nft_access_condition.fulfill(
-        nft_access_agreement_id, asset_id, consumer_account.address, pub_acc
-    )
+    # 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 keeper.condition_manager.get_condition_state(nft_holder_cond_id) == 2, ''
-    assert keeper.condition_manager.get_condition_state(nft_access_cond_id) == 2, ''
-
-    # And here checking creating an agreement first
-    # sa_access = ServiceAgreement.from_service_dict(service_access.as_dictionary())
-    #
-    # access_agreement_id = consumer_instance_no_init.assets.order(
-    #     ddo.did, sa_access.index, consumer_account, consumer_account)
-    # assert consumer_instance_no_init.assets.access(access_agreement_id, ddo.did, service_access.index, consumer_account,
-    #                                                config.downloads_path, service_type=ServiceTypes.NFT_ACCESS)
-
-    #
-    # service_access = ddo.get_service(service_type=ServiceTypes.NFT_ACCESS)
-    # sa_access = ServiceAgreement.from_service_dict(service_access.as_dictionary())
-    #
-    # access_agreement_id = consumer_instance_no_init.assets.order(
-    #     ddo.did, sa_access.index, consumer_account, consumer_account)
-    #
-    # access_agreement = keeper.agreement_manager.get_agreement(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.did_registry.balance(consumer_account.address, ddo.asset_id) >= number_nfts
-    #
-    # publisher_instance_no_init.agreements.conditions.show_nft(
-    #     access_agreement_id,
-    #     ddo.asset_id,
-    #     consumer_account.address,
-    #     number_nfts,
-    #     consumer_account
-    # )
-    #
-    # consumer_account.agreements.conditions.grant_nft_access(
-    #     access_agreement_id,
-    #     ddo.asset_id,
-    #     consumer_account.address,
-    #     pub_acc
-    # )
-    #
-    # assert keeper.condition_manager.get_condition_state(nft_holder_cond_id) == 2, ''
-    # assert keeper.condition_manager.get_condition_state(nft_access_cond_id) == 2, ''
-    #
-    # assert consumer_instance_no_init.assets.access(
-    #     access_agreement_id,
-    #     ddo.did,
-    #     sa_access.index,
-    #     consumer_account,
-    #     config.downloads_path)
+    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
+    )