Esempio n. 1
0
def execute_computation(event, agreement_id, did, service_agreement, consumer_account,
                        consume_callback, workflow_did):
    """
    Consumption of an asset after get the event call.

    :param event: AttributeDict with the event data.
    :param agreement_id: id of the agreement, hex str
    :param did: DID, str
    :param service_agreement: ServiceAgreement instance
    :param consumer_account: Account instance of the consumer
    :param consume_callback:
    :param secret_store_url: str URL of secret store node for retrieving decryption keys
    :param parity_url: str URL of parity client to use for secret store encrypt/decrypt
    :param downloads_path: str path to save downloaded files
    """
    logger.debug(f"consuming asset (agreementId {agreement_id}) after event {event}.")
    if consume_callback:
        brizo = BrizoProvider.get_brizo()
        consume_callback(
            agreement_id,
            DIDResolver(Keeper.get_instance().did_registry).resolve(did),
            DIDResolver(Keeper.get_instance().did_registry).resolve(workflow_did),
            consumer_account,
            brizo
        )
def init_ocn_tokens(ocn, account, amount=100):
    ocn.accounts.request_tokens(account, amount)
    Keeper.get_instance().token.token_approve(
        Keeper.get_instance().dispenser.address,
        amount,
        account
    )
Esempio n. 3
0
def init_ocn_tokens(ocn, account, amount=100):
    try:
        ocn.accounts.request_tokens(account, amount)
    except (ValueError, OceanInvalidTransaction):
        print(f'requesting tokens failed: {account.address}, {amount}')

    Keeper.get_instance().token.token_approve(
        Keeper.get_instance().dispenser.address, amount, account)
def refund_reward(event, agreement_id, did, service_agreement, price, consumer_account,
                  publisher_address, condition_ids, escrow_condition_id):
    """
    Refund the reward to the publisher address.

    :param event: AttributeDict with the event data.
    :param agreement_id: id of the agreement, hex str
    :param did: DID, str
    :param service_agreement: ServiceAgreement instance
    :param price: Asset price, int
    :param consumer_account: Account instance of the consumer
    :param publisher_address: ethereum account address of publisher, hex str
    :param condition_ids: is a list of bytes32 content-addressed Condition IDs, bytes32
    :param escrow_condition_id: hex str the id of escrow reward condition at this `agreement_id`
    """
    logger.debug(f"trigger refund (agreement {agreement_id}) after event {event}.")
    if Keeper.get_instance().condition_manager.get_condition_state(escrow_condition_id) > 1:
        logger.debug(
            f'escrow reward condition already fulfilled/aborted: '
            f'agreementId={agreement_id}, escrow reward conditionId={escrow_condition_id},'
            f' publisher={publisher_address}'
        )
        return

    access_id, lock_id = condition_ids[:2]
    name_to_parameter = {param.name: param for param in
                         service_agreement.condition_by_name['escrowReward'].parameters}
    document_id = add_0x_prefix(name_to_parameter['_documentId'].value)
    asset_id = add_0x_prefix(did_to_id(did))
    did_owner = Keeper.get_instance().agreement_manager.get_agreement_did_owner(agreement_id)
    assert document_id == asset_id, f'document_id {document_id} <=> asset_id {asset_id} mismatch.'
    assert price == service_agreement.get_price(), 'price mismatch.'
    try:
        escrow_condition = Keeper.get_instance().escrow_reward_condition
        tx_hash = escrow_condition.fulfill(
            agreement_id,
            price,
            Web3Provider.get_web3().toChecksumAddress(did_owner),
            consumer_account.address,
            lock_id,
            access_id,
            consumer_account
        )
        process_tx_receipt(
            tx_hash,
            getattr(escrow_condition.contract.events, escrow_condition.FULFILLED_EVENT)(),
            'EscrowReward.Fulfilled'
        )
    except Exception as e:
        logger.error(
            f'Error when doing escrow_reward_condition.fulfills (agreementId {agreement_id}): {e}',
            exc_info=1)
        raise e
Esempio n. 5
0
def setup_agreements_enviroment():
    consumer_acc = get_consumer_account()
    publisher_acc = get_publisher_account()
    keeper = Keeper.get_instance()

    ddo = get_ddo_sample()
    ddo._did = DID.did({'0': '0x987654321'})
    keeper.did_registry.register(
        ddo.asset_id,
        checksum=Web3Provider.get_web3().toBytes(hexstr=ddo.asset_id),
        url='aquarius: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()
    access_cond_id, lock_cond_id, escrow_cond_id = \
        service_agreement.generate_agreement_condition_ids(
            agreement_id, asset_id, consumer_acc.address, publisher_acc.address, keeper
        )

    return (
        keeper,
        publisher_acc,
        consumer_acc,
        agreement_id,
        asset_id,
        price,
        service_agreement,
        (lock_cond_id, access_cond_id, escrow_cond_id),
    )
def test_store_token():
    ocn_auth = OceanAuth(Keeper.get_instance(), ':memory:')
    acc = get_publisher_account()
    token = ocn_auth.store(acc)
    assert ocn_auth.check(token) == acc.address, 'invalid token, check failed.'
    # verify it is saved
    assert ocn_auth.restore(acc) == token, 'Restoring token failed.'
Esempio n. 7
0
def test_create_compute_service(publisher_ocean_instance):
    ocn_compute = publisher_ocean_instance.compute

    cluster = ocn_compute.build_cluster_attributes('kubernetes',
                                                   '/cluster/url')
    container = ocn_compute.build_container_attributes(
        "tensorflow/tensorflow", "latest",
        "sha256:cb57ecfa6ebbefd8ffc7f75c0f00e57a7fa739578a429b6f72a0df19315deadc"
    )
    server = ocn_compute.build_server_attributes("1", "xlsize", "16", "0",
                                                 "128gb", "160gb", 86400)
    provider_attributes = ocn_compute.build_service_provider_attributes(
        "Azure", "some description of the compute server instance", cluster,
        [container], [server])
    attributes = ocn_compute.create_compute_service_attributes(
        "10", 3600 * 24, publisher_ocean_instance.main_account.address,
        get_timestamp(), provider_attributes)
    service = publisher_ocean_instance.services.create_compute_service(
        attributes, 'http://brizo.com:8030/api/v1/services/compute')
    assert isinstance(service, tuple) and len(service) == 2
    assert service[0] == ServiceTypes.CLOUD_COMPUTE
    assert isinstance(service[1], dict)
    assert service[1]['templateId'] == SquidKeeper.get_instance(
    ).get_agreement_template_id(ServiceTypes.CLOUD_COMPUTE)
    assert service[1]['attributes'] == attributes
    assert service[1][
        'serviceEndpoint'] == 'http://brizo.com:8030/api/v1/services/compute'
def test_check_token(web3_instance):
    ocn_auth = OceanAuth(Keeper.get_instance(), ':memory:')
    acc = get_publisher_account()

    token = ocn_auth.get(acc)
    address = ocn_auth.check(token)
    assert address != '0x0', 'Verifying token failed.'

    sig = token.split('-')[0]
    assert ocn_auth.check(sig) == '0x0'
def test_restore_token(publisher_ocean_instance):
    ocn_auth = OceanAuth(Keeper.get_instance(), ':memory:')
    acc = get_publisher_account()
    assert ocn_auth.restore(
        acc) is None, 'Expecting None when restoring non-existing token.'

    token = ocn_auth.store(acc)
    assert ocn_auth.check(token) == acc.address, 'invalid token, check failed.'
    # verify it is saved
    assert ocn_auth.restore(acc) == token, 'Restoring token failed.'
def test_get_token():
    ocn_auth = OceanAuth(Keeper.get_instance(), ':memory:')
    acc = get_publisher_account()
    token = ocn_auth.get(acc)
    assert isinstance(token, str), 'Invalid auth token type.'
    assert token.startswith('0x'), 'Invalid auth token.'
    parts = token.split('-')
    assert len(parts) == 2, 'Invalid token, timestamp separator is not found.'

    address = ocn_auth.check(token)
    assert address != '0x0', 'Verifying token failed.'
Esempio n. 11
0
def test_get_condition_name_by_address():
    keeper = Keeper.get_instance()
    name = keeper.get_condition_name_by_address(
        keeper.lock_reward_condition.address)
    assert name == 'lockReward'

    name = keeper.get_condition_name_by_address(
        keeper.access_secret_store_condition.address)
    assert name == 'accessSecretStore'

    name = keeper.get_condition_name_by_address(
        keeper.escrow_reward_condition.address)
    assert name == 'escrowReward'
Esempio n. 12
0
def ocean_agreements():
    keeper = Keeper.get_instance()
    w3 = Web3Provider.get_web3()
    did_resolver = Mock()
    ddo = get_ddo_sample()
    service = ddo.get_service(ServiceTypes.ASSET_ACCESS)
    service.update_value(
        ServiceAgreementTemplate.TEMPLATE_ID_KEY,
        w3.toChecksumAddress("0x00bd138abd70e2f00903268f3db08f2d25677c9e"))
    did_resolver.resolve = MagicMock(return_value=ddo)
    # consumer_class = Mock
    # consumer_class.download = MagicMock(return_value='')
    return OceanAgreements(keeper, did_resolver, AssetConsumer, AssetExecutor,
                           ConfigProvider.get_config())
Esempio n. 13
0
def test_get_condition_name_by_address():
    config = ExampleConfig.get_config()
    Web3Provider.init_web3(config.keeper_url)
    ContractHandler.set_artifacts_path(config.keeper_path)
    keeper = Keeper.get_instance()
    name = keeper.get_condition_name_by_address(
        keeper.lock_reward_condition.address)
    assert name == 'lockReward'

    name = keeper.get_condition_name_by_address(
        keeper.access_secret_store_condition.address)
    assert name == 'accessSecretStore'

    name = keeper.get_condition_name_by_address(
        keeper.escrow_reward_condition.address)
    assert name == 'escrowReward'
Esempio n. 14
0
    def consume_service(service_agreement_id,
                        service_endpoint,
                        account,
                        files,
                        destination_folder,
                        index=None):
        """
        Call the brizo endpoint to get access to the different files that form the asset.

        :param service_agreement_id: Service Agreement Id, str
        :param service_endpoint: Url to consume, str
        :param account: Account instance of the consumer signing this agreement, hex-str
        :param files: List containing the files to be consumed, list
        :param index: Index of the document that is going to be downloaded, int
        :param destination_folder: Path, str
        :return: True if was downloaded, bool
        """
        signature = Keeper.get_instance().sign_hash(
            add_ethereum_prefix_and_hash_msg(service_agreement_id), account)

        if index is not None:
            assert isinstance(index,
                              int), logger.error('index has to be an integer.')
            assert index >= 0, logger.error(
                'index has to be 0 or a positive integer.')
            assert index < len(files), logger.error(
                'index can not be bigger than the number of files')
            consume_url = Brizo._create_consume_url(service_endpoint,
                                                    service_agreement_id,
                                                    account, None, signature,
                                                    index)
            logger.info(
                f'invoke consume endpoint with this url: {consume_url}')
            response = Brizo._http_client.get(consume_url, stream=True)
            file_name = Brizo._get_file_name(response)
            Brizo.write_file(response, destination_folder, file_name)
        else:
            for i, _file in enumerate(files):
                consume_url = Brizo._create_consume_url(
                    service_endpoint, service_agreement_id, account, _file,
                    signature, i)
                logger.info(
                    f'invoke consume endpoint with this url: {consume_url}')
                response = Brizo._http_client.get(consume_url, stream=True)
                file_name = Brizo._get_file_name(response)
                Brizo.write_file(response, destination_folder, file_name
                                 or f'file-{i}')
Esempio n. 15
0
def test_known_token():
    token = "0x1d2741dee30e64989ef0203957c01b14f250f5d2f6ccb0c" \
            "88c9518816e4fcec16f84e545094eb3f377b7e214ded22676" \
            "fbde8ca2e41b4eb1b3565047ecd9acf300-1568372035"
    pub_address = "0xe2DD09d719Da89e5a3D0F2549c7E24566e947260"

    ocn_auth = OceanAuth(Keeper.get_instance(), ':memory:')
    assert ocn_auth.is_token_valid(
        token), f'Invalid token!! has the token specs changed?'

    def _get_timestamp():
        return int('1568372035') + 10000

    ocn_auth._get_timestamp = _get_timestamp
    address = ocn_auth.check(token)
    assert address.lower() == pub_address.lower(), f'Recovered address {address} does not match ' \
                                                   f'known signer address {pub_address}, if the ' \
                                                   f'token generation method is changed please update ' \
                                                   f'the token in this test with the new format.'
Esempio n. 16
0
def fulfill_lock_reward_condition(event, agreement_id, price, consumer_account,
                                  lock_condition_id):
    """
    Fulfill the lock reward condition.

    :param event: AttributeDict with the event data.
    :param agreement_id: id of the agreement, hex str
    :param price: Asset price, int
    :param consumer_account: Account instance of the consumer
    :param lock_condition_id: hex str the id of the lock reward condition for this `agreement_id`
    """
    if not event:
        logger.warning(
            f'`fulfill_lock_reward_condition` got empty event: event listener timed out.'
        )
        return

    keeper = Keeper.get_instance()
    if keeper.condition_manager.get_condition_state(lock_condition_id) > 1:
        logger.debug(
            f'lock reward condition already fulfilled/aborted: '
            f'agreementId={agreement_id}, lockReward conditionId={lock_condition_id}'
        )
        return

    logger.debug(
        f"about to lock reward (agreement {agreement_id}) after event {event}."
    )

    approved = keeper.token.token_approve(keeper.lock_reward_condition.address,
                                          price, consumer_account)
    logger.info(
        f'approval of token transfer was {"" if approved else "NOT"} successful'
    )
    args = (agreement_id, keeper.escrow_reward_condition.address, price,
            consumer_account)
    process_fulfill_condition(args, keeper.lock_reward_condition,
                              lock_condition_id, logger, keeper, 10)
Esempio n. 17
0
    def execute_service(service_agreement_id, service_endpoint, account,
                        workflow_ddo):
        """

        :param service_agreement_id:
        :param service_endpoint:
        :param account:
        :return:
        """
        signature = Keeper.get_instance().sign_hash(
            add_ethereum_prefix_and_hash_msg(service_agreement_id), account)
        execute_url = Brizo._create_execute_url(service_endpoint,
                                                service_agreement_id, account,
                                                workflow_ddo.did, signature)
        logger.info(f'invoke execute endpoint with this url: {execute_url}')
        response = Brizo._http_client.post(execute_url)
        print(
            f'got brizo execute response: {response.content} with status-code {response.status_code} '
        )
        if response.status_code != 201:
            raise Exception(response.content.decode('utf-8'))

        return json.loads(response.content)['workflowId']
Esempio n. 18
0
def buy_asset():
    """
    Requires all ocean services running.

    """
    setup_logging(default_level=logging.INFO)
    ConfigProvider.set_config(ExampleConfig.get_config())
    config = ConfigProvider.get_config()
    providers = {
        'duero': '0xfEF2d5e1670342b9EF22eeeDcb287EC526B48095',
        'nile': '0x4aaab179035dc57b35e2ce066919048686f82972'
    }
    # make ocean instance
    ocn = Ocean()
    acc = get_account(1)
    if not acc:
        acc = ([acc for acc in ocn.accounts.list() if acc.password] or ocn.accounts.list())[0]

    Diagnostics.verify_contracts()
    metadata = example_metadata.metadata.copy()
    metadata['main']['dateCreated'] = get_timestamp()
    keeper = Keeper.get_instance()
    # Register ddo
    did = ''
    if did:
        ddo = ocn.assets.resolve(did)
        logging.info(f'using ddo: {did}')
    else:

        ddo = ocn.assets.create(metadata, acc, providers=[], use_secret_store=True)
        assert ddo is not None, f'Registering asset on-chain failed.'
        did = ddo.did
        logging.info(f'registered ddo: {did}')
        # ocn here will be used only to publish the asset. Handling the asset by the publisher
        # will be performed by the Brizo 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)}')

    _providers = keeper.did_registry.get_did_providers(ddo.asset_id)

    access_template_name = keeper.template_manager.SERVICE_TO_TEMPLATE_NAME['access']
    template_id = keeper.template_manager.create_template_id(access_template_name)
    approved = keeper.template_manager.is_template_approved(template_id)
    print(f'agreement template approved: {approved}')
    template_data = keeper.template_manager.get_template(template_id)
    print(f'access agreement template: {template_data}')
    cons_ocn = Ocean()
    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 Brizo which in turn will execute the agreement on-chain
    cons_ocn.accounts.request_tokens(consumer_account, 10)
    sa = ServiceAgreement.from_json(service.as_dictionary())
    agreement_id = ''
    if not agreement_id:
        agreement_id = cons_ocn.assets.order(
            did, sa.index, consumer_account)

    logging.info('placed order: %s, %s', did, agreement_id)
    event = keeper.agreement_manager.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_reward_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_secret_store_condition.subscribe_condition_fulfilled(
        agreement_id, 15, None, (), wait=True
    )
    logging.info(f'Got access event {event}')
    i = 0
    while ocn.agreements.is_access_granted(
            agreement_id, did, consumer_account.address) is not True and i < 30:
        time.sleep(1)
        i += 1

    assert ocn.agreements.is_access_granted(agreement_id, did, consumer_account.address)

    ocn.assets.consume(
        agreement_id,
        did,
        sa.index,
        consumer_account,
        config.downloads_path)
    logging.info('Success buying asset.')

    event = keeper.escrow_reward_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.')
Esempio n. 19
0
def test_buy_asset(consumer_ocean_instance, publisher_ocean_instance):
    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_ocean_instance, pub_acc)
    assert isinstance(ddo, DDO)
    # ocn here will be used only to publish the asset. Handling the asset by the publisher
    # will be performed by the Brizo server running locally

    cons_ocn = consumer_ocean_instance
    # restore the http client because we want the actual Brizo server to do the work
    # not the BrizoMock.
    # Brizo.set_http_client(requests)
    consumer_account = get_consumer_account()

    downloads_path_elements = len(
        os.listdir(
            consumer_ocean_instance._config.downloads_path)) if os.path.exists(
                consumer_ocean_instance._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_json(service.as_dictionary())
    # This will send the consume request to Brizo which in turn will execute the agreement on-chain
    cons_ocn.accounts.request_tokens(consumer_account, 100)
    agreement_id = cons_ocn.assets.order(ddo.did,
                                         sa.index,
                                         consumer_account,
                                         auto_consume=False)

    event_wait_time = 10
    event = keeper.escrow_access_secretstore_template.subscribe_agreement_created(
        agreement_id,
        event_wait_time,
        log_event(
            keeper.escrow_access_secretstore_template.AGREEMENT_CREATED_EVENT),
        (),
        wait=True)
    assert event, 'no event for EscrowAccessSecretStoreTemplate.AgreementCreated'

    event = keeper.lock_reward_condition.subscribe_condition_fulfilled(
        agreement_id,
        event_wait_time,
        log_event(keeper.lock_reward_condition.FULFILLED_EVENT), (),
        wait=True)
    assert event, 'no event for LockRewardCondition.Fulfilled'

    # give access
    publisher_ocean_instance.agreements.conditions.grant_access(
        agreement_id, ddo.did, consumer_account.address, pub_acc)
    event = keeper.access_secret_store_condition.subscribe_condition_fulfilled(
        agreement_id,
        event_wait_time,
        log_event(keeper.access_secret_store_condition.FULFILLED_EVENT), (),
        wait=True)
    assert event, 'no event for AccessSecretStoreCondition.Fulfilled'
    assert cons_ocn.agreements.is_access_granted(agreement_id, ddo.did,
                                                 consumer_account.address)

    assert cons_ocn.assets.consume(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 consume only an specific file in passing the index.
    assert cons_ocn.assets.consume(agreement_id, ddo.did, sa.index,
                                   consumer_account, config.downloads_path, 2)
    assert len(os.listdir(
        config.downloads_path)) == downloads_path_elements + 1

    with pytest.raises(AssertionError):
        cons_ocn.assets.consume(agreement_id, ddo.did, sa.index,
                                consumer_account, config.downloads_path, -2)

    with pytest.raises(AssertionError):
        cons_ocn.assets.consume(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
    try:
        cons_ocn.assets.consume(agreement_id, ddo.did, sa.index, pub_acc,
                                config.downloads_path)
    except RPCError:
        print('hooray, secret store is working as expected.')

    publisher_ocean_instance.agreements.conditions.release_reward(
        agreement_id, sa.get_price(), pub_acc)

    event = keeper.escrow_reward_condition.subscribe_condition_fulfilled(
        agreement_id,
        event_wait_time + 20,
        log_event(keeper.escrow_reward_condition.FULFILLED_EVENT), (),
        wait=True)
    assert event, 'no event for EscrowReward.Fulfilled'

    assert w3.toHex(event.args['_agreementId']) == agreement_id
Esempio n. 20
0
def setup_all():
    config = ExampleConfig.get_config()
    Web3Provider.init_web3(config.keeper_url)
    ContractHandler.set_artifacts_path(config.keeper_path)
    Keeper.get_instance()
Esempio n. 21
0
    def __init__(self, config=None):
        """
        Initialize Ocean class.
           >> # Make a new Ocean instance
           >> ocean = Ocean({...})

        This class provides the main top-level functions in ocean protocol:
         * Publish assets metadata and associated services
            * Each asset is assigned a unique DID and a DID Document (DDO)
            * The DDO contains the asset's services including the metadata
            * The DID is registered on-chain with a URL of the metadata store
              to retrieve the DDO from

            >> ddo = ocean.assets.create(metadata, publisher_account)

         * Discover/Search assets via the current configured metadata store (Aquarius)
            >> assets_list = ocean.assets.search('search text')

         * Purchase asset services by choosing a service agreement from the
           asset's DDO. Purchase goes through the service agreements interface
           and starts by signing a service agreement then sending the signature
           to the publisher's Brizo server via the `purchaseEndpoint` in the service
           definition:

           >> service_def_id = ddo.get_service(ServiceTypes.ASSET_ACCESS).service_definition_id
           >> service_agreement_id = ocean.assets.order(did, service_def_id, consumer_account)

        An instance of Ocean is parameterized by a `Config` instance.

        :param config: Config instance
        """
        # Configuration information for the market is stored in the Config class
        # config = Config(filename=config_file, options_dict=config_dict)
        if not config:
            config = ConfigProvider.get_config()

        self._config = config
        self._web3 = Web3Provider.get_web3(self._config.keeper_url)
        ContractHandler.set_artifacts_path(self._config.keeper_path)
        contracts = [
            'DIDRegistry', 'Dispenser', 'TemplateStoreManager', 'OceanToken',
            'ConditionStoreManager', 'EscrowAccessSecretStoreTemplate',
            'AgreementStoreManager', 'AgreementStoreManager',
            'AccessSecretStoreCondition', 'LockRewardCondition',
            'HashLockCondition', 'SignCondition', 'EscrowReward'
        ]
        self._keeper = Keeper.get_instance(contracts)
        self._did_resolver = DIDResolver(self._keeper.did_registry)

        # Initialize the public sub-modules
        self.tokens = OceanTokens(self._keeper)
        self.accounts = OceanAccounts(self._keeper, self._config, self.tokens)
        self.secret_store = OceanSecretStore(self._config)
        self.templates = OceanTemplates(self._keeper, config)
        self.agreements = self._make_ocean_agreements()
        self.assets = OceanAssets(self._keeper, self._did_resolver,
                                  self.agreements, AssetConsumer,
                                  AssetExecutor, self._config)
        self.services = OceanServices()
        self.ocean_providers = OceanProviders(self._keeper, self._did_resolver,
                                              self._config)
        self.auth = OceanAuth(self._keeper, self._config.storage_path)

        logger.debug('Squid Ocean instance initialized: ')
        logger.debug(
            f'\tOther accounts: {sorted([a.address for a in self.accounts.list()])}'
        )
        logger.debug(f'\tDIDRegistry @ {self._keeper.did_registry.address}')
Esempio n. 22
0
def test_sign_agreement(publisher_ocean_instance, consumer_ocean_instance,
                        registered_ddo):
    # point consumer_ocean_instance's brizo mock to the publisher's ocean instance
    BrizoProvider.set_brizo_class(BrizoMock)

    consumer_ocn = consumer_ocean_instance
    consumer_acc = consumer_ocn.main_account
    keeper = Keeper.get_instance()

    pub_ocn = publisher_ocean_instance
    publisher_acc = pub_ocn.main_account

    did = registered_ddo.did
    asset_id = registered_ddo.asset_id
    ddo = consumer_ocn.assets.resolve(did)
    service_agreement = ServiceAgreement.from_ddo(ServiceTypes.ASSET_ACCESS,
                                                  ddo)

    price = service_agreement.get_price()

    # Give consumer some tokens
    keeper.dispenser.request_vodkas(price * 2, consumer_acc)

    agreement_id, signature = consumer_ocean_instance.agreements.prepare(
        did, consumer_acc, ServiceTypesIndices.DEFAULT_ACCESS_INDEX)

    success = publisher_ocean_instance.agreements.create(
        did, ServiceTypesIndices.DEFAULT_ACCESS_INDEX, agreement_id, signature,
        consumer_acc.address, publisher_acc)
    assert success, 'createAgreement failed.'

    event = keeper.agreement_manager.subscribe_agreement_created(
        agreement_id,
        10,
        log_event(keeper.agreement_manager.AGREEMENT_CREATED_EVENT), (),
        wait=True)
    assert event, 'no event for AgreementCreated '

    # Verify condition types (condition contracts)
    agreement_values = keeper.agreement_manager.get_agreement(agreement_id)
    assert agreement_values.did == asset_id, ''
    template_id = keeper.get_agreement_template_id(service_agreement.type)
    cond_types = keeper.template_manager.get_template(
        template_id).condition_types
    for i, cond_id in enumerate(agreement_values.condition_ids):
        cond = keeper.condition_manager.get_condition(cond_id)
        assert cond.type_ref == cond_types[i]
        assert int(cond.state) == 1

    lock_cond_id, access_cond_id, escrow_cond_id = agreement_values.condition_ids
    # Fulfill lock_reward_condition
    starting_balance = keeper.token.get_token_balance(
        keeper.escrow_reward_condition.address)
    keeper.token.token_approve(keeper.lock_reward_condition.address, price,
                               consumer_acc)
    tx_hash = keeper.lock_reward_condition.fulfill(
        agreement_id, keeper.escrow_reward_condition.address, price,
        consumer_acc)
    keeper.lock_reward_condition.get_tx_receipt(tx_hash)
    assert keeper.token.get_token_balance(
        keeper.escrow_reward_condition.address) == (price +
                                                    starting_balance), ''
    assert keeper.condition_manager.get_condition_state(lock_cond_id) == 2, ''
    event = keeper.lock_reward_condition.subscribe_condition_fulfilled(
        agreement_id,
        10,
        log_event(keeper.lock_reward_condition.FULFILLED_EVENT), (),
        wait=True)
    assert event, 'no event for LockRewardCondition.Fulfilled'

    # Fulfill access_secret_store_condition
    tx_hash = keeper.access_secret_store_condition.fulfill(
        agreement_id, asset_id, consumer_acc.address, publisher_acc)
    keeper.access_secret_store_condition.get_tx_receipt(tx_hash)
    assert 2 == keeper.condition_manager.get_condition_state(
        access_cond_id), ''
    event = keeper.access_secret_store_condition.subscribe_condition_fulfilled(
        agreement_id,
        10,
        log_event(keeper.access_secret_store_condition.FULFILLED_EVENT), (),
        wait=True)
    assert event, 'no event for AccessSecretStoreCondition.Fulfilled'

    # Fulfill escrow_reward_condition
    tx_hash = keeper.escrow_reward_condition.fulfill(
        agreement_id, price, publisher_acc.address, consumer_acc.address,
        lock_cond_id, access_cond_id, publisher_acc)
    keeper.escrow_reward_condition.get_tx_receipt(tx_hash)
    assert 2 == keeper.condition_manager.get_condition_state(
        escrow_cond_id), ''
    event = keeper.escrow_reward_condition.subscribe_condition_fulfilled(
        agreement_id,
        10,
        log_event(keeper.escrow_reward_condition.FULFILLED_EVENT), (),
        wait=True)
    assert event, 'no event for EscrowReward.Fulfilled'
    publisher_ocean_instance.assets.retire(did)