def test_agreement_direct(publisher_instance, consumer_instance, metadata):
publisher_account = publisher_instance.main_account
consumer_account = consumer_instance.main_account
ddo = publisher_instance.assets.create(metadata, publisher_account,
providers=[
'0x068Ed00cF0441e4829D9784fCBe7b9e26D4BD8d0'])
agreement_id = consumer_instance.assets.order(ddo.did,
ServiceTypesIndices.DEFAULT_ACCESS_INDEX,
consumer_account,
consumer_account
)
assert publisher_instance.agreements.status(agreement_id)
keeper = publisher_instance.keeper
event = keeper.lock_payment_condition.subscribe_condition_fulfilled(
agreement_id,
10,
log_event(keeper.lock_payment_condition.FULFILLED_EVENT),
(),
wait=True
)
assert event, 'no event for LockRewardCondition.Fulfilled'
assert publisher_instance.agreements.is_access_granted(agreement_id, ddo.did,
consumer_account.address)
publisher_instance.assets.retire(ddo.did)
def test_assets_consumed(publisher_ocean_instance, consumer_ocean_instance):
ocn = publisher_ocean_instance
acct = consumer_ocean_instance.main_account
consumed_assets = len(ocn.assets.consumer_assets(acct.address))
asset = create_asset(publisher_ocean_instance)
service = asset.get_service(service_type=ServiceTypes.ASSET_ACCESS)
service_dict = service.as_dictionary()
sa = ServiceAgreement.from_json(service_dict)
keeper = ocn.keeper
def grant_access(_, ocn_instance, agr_id, did, cons_address, account):
ocn_instance.agreements.conditions.grant_access(
agr_id, did, cons_address, account)
agreement_id = consumer_ocean_instance.assets.order(
asset.did, sa.index, acct)
keeper.lock_reward_condition.subscribe_condition_fulfilled(
agreement_id,
15,
grant_access, (publisher_ocean_instance, agreement_id, asset.did,
acct.address, publisher_ocean_instance.main_account),
wait=True)
keeper.access_secret_store_condition.subscribe_condition_fulfilled(
agreement_id,
15,
log_event(keeper.access_secret_store_condition.FULFILLED_EVENT), (),
wait=True)
assert ocn.agreements.is_access_granted(agreement_id, asset.did,
acct.address)
assert len(ocn.assets.consumer_assets(acct.address)) == consumed_assets + 1
publisher_ocean_instance.assets.retire(asset.did)
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_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
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
Brizo.set_http_client(
BrizoMock(publisher_ocean_instance,
publisher_ocean_instance.main_account))
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
service_definition_id = '1'
did = registered_ddo.did
asset_id = registered_ddo.asset_id
ddo = consumer_ocn.assets.resolve(did)
service_agreement = ServiceAgreement.from_ddo(service_definition_id, ddo)
price = service_agreement.get_price()
# Give consumer some tokens
keeper.dispenser.request_tokens(price * 2, consumer_acc)
agreement_id, signature = consumer_ocean_instance.agreements.prepare(
did, service_agreement.service_definition_id, consumer_acc)
success = publisher_ocean_instance.agreements.create(
did, service_agreement.service_definition_id, agreement_id, signature,
consumer_acc.address, publisher_acc)
assert success, 'createAgreement failed.'
event = keeper.escrow_access_secretstore_template.subscribe_agreement_created(
agreement_id,
10,
log_event(
keeper.escrow_access_secretstore_template.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, ''
cond_types = keeper.escrow_access_secretstore_template.get_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
access_cond_id, lock_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)
keeper.lock_reward_condition.fulfill(
agreement_id, keeper.escrow_reward_condition.address, price,
consumer_acc)
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
keeper.access_secret_store_condition.fulfill(agreement_id, asset_id,
consumer_acc.address,
publisher_acc)
assert keeper.condition_manager.get_condition_state(
access_cond_id) == 2, ''
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
keeper.escrow_reward_condition.fulfill(agreement_id, price,
publisher_acc.address,
consumer_acc.address, lock_cond_id,
access_cond_id, publisher_acc)
assert keeper.condition_manager.get_condition_state(
escrow_cond_id) == 2, ''
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'
def test_agreement_status(ocean_agreements):
(
keeper,
publisher_acc,
consumer_acc,
agreement_id,
asset_id,
price,
service_agreement,
(lock_cond_id, access_cond_id, escrow_cond_id),
) = setup_agreements_environment()
template_id = keeper.get_agreement_template_id(service_agreement.type)
success = keeper.agreement_manager.create_agreement(
agreement_id, asset_id, template_id,
[lock_cond_id, access_cond_id, escrow_cond_id],
service_agreement.conditions_timelocks,
service_agreement.conditions_timeouts,
[consumer_acc.address, publisher_acc.address], publisher_acc)
print('create agreement: ', success)
assert success, f'createAgreement failed {success}'
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 '
assert ocean_agreements.status(agreement_id) == {
"agreementId": agreement_id,
"conditions": {
"lockReward": 1,
"accessSecretStore": 1,
"escrowReward": 1
}
}
# keeper.dispenser.request_vodkas(price, consumer_acc)
# keeper.token.token_approve(keeper.lock_reward_condition.address, price, consumer_acc)
ocean_agreements.conditions.lock_reward(agreement_id, price, consumer_acc)
# keeper.lock_reward_condition.fulfill(
# agreement_id, keeper.escrow_reward_condition.address, price, consumer_acc)
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'
assert ocean_agreements.status(agreement_id) == {
"agreementId": agreement_id,
"conditions": {
"lockReward": 2,
"accessSecretStore": 1,
"escrowReward": 1
}
}
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)
event = keeper.access_secret_store_condition.subscribe_condition_fulfilled(
agreement_id,
20,
log_event(keeper.access_secret_store_condition.FULFILLED_EVENT), (),
wait=True)
assert event, 'no event for AccessSecretStoreCondition.Fulfilled'
assert ocean_agreements.status(agreement_id) == {
"agreementId": agreement_id,
"conditions": {
"lockReward": 2,
"accessSecretStore": 2,
"escrowReward": 1
}
}
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)
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'
assert ocean_agreements.status(agreement_id) == {
"agreementId": agreement_id,
"conditions": {
"lockReward": 2,
"accessSecretStore": 2,
"escrowReward": 2
}
}
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)
def test_agreement_status(setup_agreements_environment, agreements):
(
keeper,
publisher_acc,
consumer_acc,
agreement_id,
asset_id,
price,
service_agreement,
(lock_cond_id, access_cond_id, escrow_cond_id),
) = setup_agreements_environment
success = keeper.access_template.create_agreement(
agreement_id, asset_id, [access_cond_id, lock_cond_id, escrow_cond_id],
service_agreement.conditions_timelocks,
service_agreement.conditions_timeouts, consumer_acc.address,
publisher_acc)
print('create agreement: ', success)
assert success, f'createAgreement failed {success}'
event = keeper.access_template.subscribe_agreement_created(
agreement_id,
10,
log_event(keeper.access_template.AGREEMENT_CREATED_EVENT), (),
wait=True)
assert event, 'no event for AgreementCreated '
assert agreements.status(agreement_id) == {
"agreementId": agreement_id,
"conditions": {
"lockReward": 1,
"accessSecretStore": 1,
"escrowReward": 1
}
}
amounts = service_agreement.get_amounts_int()
receivers = service_agreement.get_receivers()
agreements.conditions.lock_payment(agreement_id, asset_id, amounts,
receivers, consumer_acc)
event = keeper.lock_payment_condition.subscribe_condition_fulfilled(
agreement_id,
10,
log_event(keeper.lock_payment_condition.FULFILLED_EVENT), (),
wait=True)
assert event, 'no event for LockRewardCondition.Fulfilled'
assert agreements.status(agreement_id) == {
"agreementId": agreement_id,
"conditions": {
"lockReward": 2,
"accessSecretStore": 1,
"escrowReward": 1
}
}
tx_hash = keeper.access_condition.fulfill(agreement_id, asset_id,
consumer_acc.address,
publisher_acc)
keeper.access_condition.get_tx_receipt(tx_hash)
event = keeper.access_condition.subscribe_condition_fulfilled(
agreement_id,
20,
log_event(keeper.access_condition.FULFILLED_EVENT), (),
wait=True)
assert event, 'no event for AccessSecretStoreCondition.Fulfilled'
assert agreements.status(agreement_id) == {
"agreementId": agreement_id,
"conditions": {
"lockReward": 2,
"accessSecretStore": 2,
"escrowReward": 1
}
}
tx_hash = keeper.escrow_payment_condition.fulfill(
agreement_id, asset_id, amounts, receivers,
keeper.escrow_payment_condition.address, lock_cond_id, access_cond_id,
publisher_acc)
keeper.escrow_payment_condition.get_tx_receipt(tx_hash)
event = keeper.escrow_payment_condition.subscribe_condition_fulfilled(
agreement_id,
10,
log_event(keeper.escrow_payment_condition.FULFILLED_EVENT), (),
wait=True)
assert event, 'no event for EscrowReward.Fulfilled'
assert agreements.status(agreement_id) == {
"agreementId": agreement_id,
"conditions": {
"lockReward": 2,
"accessSecretStore": 2,
"escrowReward": 2
}
}
def test_sign_agreement(publisher_instance, consumer_instance, registered_ddo):
# point consumer_instance's Gateway mock to the publisher's nevermined instance
Gateway.set_http_client(
GatewayMock(publisher_instance, publisher_instance.main_account))
consumer_acc = consumer_instance.main_account
keeper = Keeper.get_instance()
publisher_acc = publisher_instance.main_account
did = registered_ddo.did
asset_id = registered_ddo.asset_id
ddo = consumer_instance.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_instance.agreements.prepare(
did, consumer_acc, ServiceTypesIndices.DEFAULT_ACCESS_INDEX)
success = publisher_instance.agreements.create(
did, ServiceTypesIndices.DEFAULT_ACCESS_INDEX, agreement_id,
consumer_acc.address, publisher_acc)
assert success, 'createAgreement failed.'
# Verify condition types (condition contracts)
agreement_values = keeper.agreement_manager.get_agreement(agreement_id)
assert agreement_values.did == asset_id, ''
cond_types = keeper.access_template.get_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]
access_cond_id, lock_cond_id, escrow_cond_id = agreement_values.condition_ids
# Fulfill lock_payment_condition is done automatically when create agreement is done correctly
assert 2 == keeper.condition_manager.get_condition_state(lock_cond_id), ''
assert 1 == keeper.condition_manager.get_condition_state(
access_cond_id), ''
assert 1 == keeper.condition_manager.get_condition_state(
escrow_cond_id), ''
# Fulfill access_condition
tx_hash = keeper.access_condition.fulfill(agreement_id, asset_id,
consumer_acc.address,
publisher_acc)
keeper.access_condition.get_tx_receipt(tx_hash)
assert 2 == keeper.condition_manager.get_condition_state(
access_cond_id), ''
event = keeper.access_condition.subscribe_condition_fulfilled(
agreement_id,
10,
log_event(keeper.access_condition.FULFILLED_EVENT), (),
wait=True)
assert event, 'no event for AccessSecretStoreCondition.Fulfilled'
# Fulfill escrow_payment_condition
amounts = service_agreement.get_amounts_int()
receivers = service_agreement.get_receivers()
tx_hash = keeper.escrow_payment_condition.fulfill(
agreement_id, asset_id, amounts, receivers,
keeper.escrow_payment_condition.address, lock_cond_id, access_cond_id,
publisher_acc)
keeper.escrow_payment_condition.get_tx_receipt(tx_hash)
assert 2 == keeper.condition_manager.get_condition_state(
escrow_cond_id), ''
event = keeper.escrow_payment_condition.subscribe_condition_fulfilled(
agreement_id,
10,
log_event(keeper.escrow_payment_condition.FULFILLED_EVENT), (),
wait=True)
assert event, 'no event for EscrowReward.Fulfilled'
publisher_instance.assets.retire(did)
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 test_escrow_access_secret_store_template_flow():
"""
Test the agreement flow according to the EscrowAccessSecretStoreTemplate
"""
(
keeper,
publisher_acc,
consumer_acc,
agreement_id,
asset_id,
price,
service_agreement,
(lock_cond_id, access_cond_id, escrow_cond_id),
) = setup_things()
print('creating agreement:'
'agrId: ', agreement_id, 'asset_id', asset_id,
'[lock_cond_id, access_cond_id, escrow_cond_id]',
[lock_cond_id, access_cond_id, escrow_cond_id], 'tlocks',
service_agreement.conditions_timelocks, 'touts',
service_agreement.conditions_timeouts, 'consumer',
consumer_acc.address, 'publisher', publisher_acc.address)
assert keeper.template_manager.is_template_approved(
keeper.escrow_access_secretstore_template.address
), 'Template is not approved.'
assert keeper.did_registry.get_block_number_updated(
asset_id) > 0, 'asset id not registered'
success = keeper.escrow_access_secretstore_template.create_agreement(
agreement_id, asset_id, [access_cond_id, lock_cond_id, escrow_cond_id],
service_agreement.conditions_timelocks,
service_agreement.conditions_timeouts, consumer_acc.address,
publisher_acc)
print('create agreement: ', success)
assert success, f'createAgreement failed {success}'
event = keeper.escrow_access_secretstore_template.subscribe_agreement_created(
agreement_id,
10,
log_event(
keeper.escrow_access_secretstore_template.AGREEMENT_CREATED_EVENT),
(),
wait=True)
assert event, 'no event for AgreementCreated '
# Verify condition types (condition contracts)
agreement = keeper.agreement_manager.get_agreement(agreement_id)
assert agreement.did == asset_id, ''
cond_types = keeper.escrow_access_secretstore_template.get_condition_types(
)
for i, cond_id in enumerate(agreement.condition_ids):
cond = keeper.condition_manager.get_condition(cond_id)
assert cond.type_ref == cond_types[i]
assert int(cond.state) == 1
# Give consumer some tokens
keeper.dispenser.request_tokens(price, consumer_acc)
# Fulfill lock_reward_condition
pub_token_balance = keeper.token.get_token_balance(publisher_acc.address)
starting_balance = keeper.token.get_token_balance(
keeper.escrow_reward_condition.address)
keeper.token.token_approve(keeper.lock_reward_condition.address, price,
consumer_acc)
keeper.lock_reward_condition.fulfill(
agreement_id, keeper.escrow_reward_condition.address, price,
consumer_acc)
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'
assert keeper.condition_manager.get_condition_state(lock_cond_id) == 2, ''
assert keeper.token \
.get_token_balance(keeper.escrow_reward_condition.address) == (
price + starting_balance), ''
# Fulfill access_secret_store_condition
keeper.access_secret_store_condition.fulfill(agreement_id, asset_id,
consumer_acc.address,
publisher_acc)
event = keeper.access_secret_store_condition.subscribe_condition_fulfilled(
agreement_id,
20,
log_event(keeper.access_secret_store_condition.FULFILLED_EVENT), (),
wait=True)
assert event, 'no event for AccessSecretStoreCondition.Fulfilled'
assert keeper.condition_manager.get_condition_state(
access_cond_id) == 2, ''
# Fulfill escrow_reward_condition
keeper.escrow_reward_condition.fulfill(agreement_id, price,
publisher_acc.address,
consumer_acc.address, lock_cond_id,
access_cond_id, publisher_acc)
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'
assert keeper.condition_manager.get_condition_state(
escrow_cond_id) == 2, ''
assert keeper.token \
.get_token_balance(keeper.escrow_reward_condition.address) == starting_balance, ''
assert keeper.token \
.get_token_balance(publisher_acc.address) == (pub_token_balance + price), ''
def test_access_template_flow(setup_agreements_environment):
"""Test the agreement flow according to the AccessTemplate."""
(
keeper,
ddo,
publisher_acc,
consumer_acc,
agreement_id,
asset_id,
price,
service_agreement,
(lock_cond_id, access_cond_id, escrow_cond_id),
) = setup_agreements_environment
print('creating agreement:'
'agrId: ', agreement_id, 'asset_id', asset_id,
'[lock_cond_id, access_cond_id, escrow_cond_id]',
[lock_cond_id, access_cond_id, escrow_cond_id], 'tlocks',
service_agreement.conditions_timelocks, 'touts',
service_agreement.conditions_timeouts, 'consumer',
consumer_acc.address, 'publisher', publisher_acc.address)
amounts = service_agreement.get_amounts_int()
receivers = service_agreement.get_receivers()
# receivers = [publisher_acc.address, '0x2B5AD5c4795c026514f8317c7a215E218DcCD6cF']
token_address = keeper.token.address
receiver_0_starting_balance = keeper.token.get_token_balance(
keeper.agreement_manager.to_checksum_address(receivers[0]))
assert keeper.template_manager.is_template_approved(
keeper.access_template.address), 'Template is not approved.'
assert keeper.did_registry.get_block_number_updated(
asset_id) > 0, 'asset id not registered'
success = keeper.access_template.create_agreement(
agreement_id, asset_id, [access_cond_id, lock_cond_id, escrow_cond_id],
service_agreement.conditions_timelocks,
service_agreement.conditions_timeouts, consumer_acc.address,
publisher_acc)
print('create agreement: ', success)
assert success, f'createAgreement failed {success}'
event = keeper.access_template.subscribe_agreement_created(
agreement_id,
10,
log_event(keeper.access_template.AGREEMENT_CREATED_EVENT), (),
wait=True)
assert event, 'no event for AgreementCreated '
# Verify condition types (condition contracts)
agreement = keeper.agreement_manager.get_agreement(agreement_id)
assert agreement.did == asset_id, ''
cond_types = keeper.access_template.get_condition_types()
for i, cond_id in enumerate(agreement.condition_ids):
cond = keeper.condition_manager.get_condition(cond_id)
assert cond.type_ref == cond_types[i]
assert int(cond.state) == 1
# Give consumer some tokens
keeper.dispenser.request_vodkas(price, consumer_acc)
# Fulfill lock_payment_condition
pub_token_balance = keeper.token.get_token_balance(publisher_acc.address)
starting_balance = keeper.token.get_token_balance(
keeper.escrow_payment_condition.address)
keeper.token.token_approve(keeper.lock_payment_condition.address, price,
consumer_acc)
tx_hash = keeper.lock_payment_condition.fulfill(
agreement_id, asset_id, keeper.escrow_payment_condition.address,
token_address, amounts, receivers, consumer_acc)
keeper.lock_payment_condition.get_tx_receipt(tx_hash)
event = keeper.lock_payment_condition.subscribe_condition_fulfilled(
agreement_id,
10,
log_event(keeper.lock_payment_condition.FULFILLED_EVENT), (),
wait=True)
assert event, 'no event for LockPaymentCondition.Fulfilled'
assert keeper.condition_manager.get_condition_state(lock_cond_id) == 2, ''
assert keeper.token.get_token_balance(
keeper.escrow_payment_condition.address) == (price +
starting_balance), ''
# Fulfill access_condition
tx_hash = keeper.access_condition.fulfill(agreement_id, asset_id,
consumer_acc.address,
publisher_acc)
keeper.access_condition.get_tx_receipt(tx_hash)
event = keeper.access_condition.subscribe_condition_fulfilled(
agreement_id,
20,
log_event(keeper.access_condition.FULFILLED_EVENT), (),
wait=True)
assert event, 'no event for AccessCondition.Fulfilled'
assert keeper.condition_manager.get_condition_state(
access_cond_id) == 2, ''
# Fulfill escrow_payment_condition
tx_hash = keeper.escrow_payment_condition.fulfill(
agreement_id, asset_id, amounts, receivers,
keeper.escrow_payment_condition.address, token_address, lock_cond_id,
access_cond_id, publisher_acc)
keeper.escrow_payment_condition.get_tx_receipt(tx_hash)
event = keeper.escrow_payment_condition.subscribe_condition_fulfilled(
agreement_id,
10,
log_event(keeper.escrow_payment_condition.FULFILLED_EVENT), (),
wait=True)
assert event, 'no event for EscrowPayment.Fulfilled'
assert keeper.condition_manager.get_condition_state(
escrow_cond_id) == 2, ''
assert keeper.token.get_token_balance(
keeper.escrow_payment_condition.address) == starting_balance, ''
assert keeper.token.get_token_balance(
keeper.agreement_manager.to_checksum_address(
receivers[0])) == (receiver_0_starting_balance +
int(amounts[0])), ''
