def release_reward(self, agreement_id, asset_id, amounts, receivers,
token_address, account):
"""
Release reward condition.
:param agreement_id: id of the agreement, hex str
:param asset_id: asset id, str
:param amounts: Amounts of tokens, int[]
:param receivers: Token receivers, str[]
:param token_address: ERC20 address or 0x0 if ETH payment
:param account sending the transaction
:return:
"""
agreement_values = self._keeper.agreement_manager.get_agreement(
agreement_id)
consumer, provider = self._keeper.access_template.get_agreement_data(
agreement_id)
owner = agreement_values.owner
access_id, lock_id = agreement_values.condition_ids[:2]
tx_hash = self._keeper.escrow_payment_condition.fulfill(
agreement_id, asset_id, amounts, to_checksum_addresses(receivers),
self._keeper.escrow_payment_condition.address, token_address,
lock_id, access_id, account)
receipt = self._keeper.escrow_payment_condition.get_tx_receipt(tx_hash)
return bool(receipt and receipt.status == 1)
def lock_payment(self, agreement_id, asset_id, amounts, receivers,
token_address, account):
"""
Lock reward condition.
:param agreement_id: id of the agreement, hex str
:param asset_id: asset identifier, str
:param amounts: Amount of tokens, str[]
:param receivers: Tokens receivers, str[]
:param token_address: ERC20 token address or 0x0 if ETH
:param account: Account
:return: bool
"""
total_price = 0
for amount in amounts:
total_price = total_price + int(amount)
self._keeper.token.token_approve(
self._keeper.lock_payment_condition.address, total_price, account)
tx_hash = self._keeper.lock_payment_condition.fulfill(
agreement_id, asset_id,
self._keeper.escrow_payment_condition.address, token_address,
amounts, to_checksum_addresses(receivers), account)
receipt = self._keeper.lock_payment_condition.get_tx_receipt(tx_hash)
return bool(receipt and receipt.status == 1)
def get_registered_ddo(account,
providers=None,
auth_service='PSK-RSA',
url=get_file_url()):
ddo = get_sample_ddo()
metadata = ddo['service'][0]['attributes']
metadata['main']['files'][0]['url'] = url
metadata['main']['files'][0]['checksum'] = str(uuid.uuid4())
escrow_payment_condition = ddo['service'][1]['attributes'][
'serviceAgreementTemplate']['conditions'][2]
_amounts = get_param_value_by_name(escrow_payment_condition['parameters'],
'_amounts')
_receivers = to_checksum_addresses(
get_param_value_by_name(escrow_payment_condition['parameters'],
'_receivers'))
access_service_attributes = {
"main": {
"name": "dataAssetAccessServiceAgreement",
"creator": account.address,
"price": metadata[MetadataMain.KEY]['price'],
"timeout": 3600,
"datePublished": metadata[MetadataMain.KEY]['dateCreated'],
"_amounts": _amounts,
"_receivers": _receivers
}
}
access_service_descriptor = ServiceDescriptor.access_service_descriptor(
access_service_attributes, 'http://localhost:8030')
return register_ddo(metadata, account, providers, auth_service,
[access_service_descriptor])
def get_nft_ddo(account, providers=None, auth_service='PSK-RSA'):
ddo = get_sample_nft_ddo()
metadata = ddo['service'][0]['attributes']
metadata['main']['files'][0][
'url'] = "https://raw.githubusercontent.com/tbertinmahieux/MSongsDB/master/Tasks_Demos" \
"/CoverSongs/shs_dataset_test.txt?" + str(uuid.uuid4())
metadata['main']['files'][0]['checksum'] = str(uuid.uuid4())
escrow_payment_condition = ddo['service'][1]['attributes'][
'serviceAgreementTemplate']['conditions'][2]
_number_nfts = 1
# _amounts = get_param_value_by_name(escrow_payment_condition['parameters'], '_amounts')
# _receivers = to_checksum_addresses(
# get_param_value_by_name(escrow_payment_condition['parameters'], '_receivers'))
_amounts = ['9']
_receivers = to_checksum_addresses([account.address])
transfer_nft_condition = ddo['service'][1]['attributes'][
'serviceAgreementTemplate']['conditions'][1]
# _nftHolder = get_param_value_by_name(transfer_nft_condition['parameters'], '_nftHolder')
_nftHolder = to_checksum_address(account.address)
_total_price = sum(int(x) for x in _amounts)
asset_rewards = {"_amounts": _amounts, "_receivers": _receivers}
metadata['main']['price'] = _total_price
access_service_attributes = {
"main": {
"name": "nftAccessAgreement",
"creator": account.address,
"timeout": 3600,
"price": _total_price,
"_amounts": _amounts,
"_receivers": _receivers,
"_numberNfts": str(_number_nfts),
"_tokenAddress": "",
"datePublished": metadata['main']['dateCreated']
}
}
sales_service_attributes = copy.deepcopy(access_service_attributes)
sales_service_attributes['main']['name'] = 'nftSalesAgreement'
sales_service_attributes['main']['_nftHolder'] = _nftHolder
nft_sales_service_descriptor = ServiceDescriptor.nft_sales_service_descriptor(
sales_service_attributes, 'http://localhost:8030')
nft_access_service_descriptor = ServiceDescriptor.nft_access_service_descriptor(
access_service_attributes, 'http://localhost:8030')
return register_ddo(
metadata,
account,
providers,
auth_service,
[nft_access_service_descriptor, nft_sales_service_descriptor],
royalties=0,
cap=10,
mint=10)
def get_receivers(self):
"""
Return the list of receivers addresses
:return: str[]
"""
return to_checksum_addresses(
self.get_param_value_by_name('_receivers'))
def get_registered_ddo_nft(nevermined_instance, account):
ddo = get_sample_nft_ddo()
metadata = ddo['service'][0]['attributes']
metadata['main']['files'][0][
'url'] = "https://raw.githubusercontent.com/tbertinmahieux/MSongsDB/master/Tasks_Demos" \
"/CoverSongs/shs_dataset_test.txt?" + str(uuid.uuid4())
metadata['main']['files'][0]['checksum'] = str(uuid.uuid4())
escrow_payment_condition = ddo['service'][1]['attributes'][
'serviceAgreementTemplate']['conditions'][2]
_number_nfts = 1
_amounts = get_param_value_by_name(escrow_payment_condition['parameters'],
'_amounts')
_receivers = to_checksum_addresses(
get_param_value_by_name(escrow_payment_condition['parameters'],
'_receivers'))
_total_price = 0
for i in _amounts:
_total_price += int(i)
asset_rewards = {"_amounts": _amounts, "_receivers": _receivers}
metadata['main']['price'] = _total_price
access_service_attributes = {
"main": {
"name": "nftAccessAgreement",
"creator": account.address,
"timeout": 3600,
"price": _total_price,
"_amounts": _amounts,
"_receivers": _receivers,
"_numberNfts": str(_number_nfts),
"datePublished": metadata['main']['dateCreated']
}
}
sales_service_attributes = access_service_attributes
sales_service_attributes['main']['name'] = 'nftSalesAgreement'
nft_sales_service_descriptor = ServiceDescriptor.nft_sales_service_descriptor(
sales_service_attributes, 'http://localhost:8030')
nft_access_service_descriptor = ServiceDescriptor.nft_access_service_descriptor(
access_service_attributes, 'http://localhost:8030')
ddo = nevermined_instance.assets.create(
metadata,
account, [nft_sales_service_descriptor, nft_access_service_descriptor],
asset_rewards=asset_rewards,
royalties=0,
cap=10,
mint=10)
return ddo
def get_proof_ddo(account,
providers=None,
auth_service='PSK-RSA',
key=get_key()):
ddo = get_sample_ddo()
metadata = ddo['service'][0]['attributes']
metadata['main']['files'][0]['url'] = key
metadata['main']['files'][0]['checksum'] = str(uuid.uuid4())
hash = poseidon_hash(key)
providerKey = get_provider_public_key()
metadata['additionalInformation'] = {
"providerKey": {
"x": providerKey[0],
"y": providerKey[1]
},
"poseidonHash": hash
}
escrow_payment_condition = ddo['service'][1]['attributes'][
'serviceAgreementTemplate']['conditions'][2]
_amounts = get_param_value_by_name(escrow_payment_condition['parameters'],
'_amounts')
_receivers = to_checksum_addresses(
get_param_value_by_name(escrow_payment_condition['parameters'],
'_receivers'))
access_service_attributes = {
"main": {
"name": "dataAssetAccessProofServiceAgreement",
"creator": account.address,
"price": metadata[MetadataMain.KEY]['price'],
"timeout": 3600,
"datePublished": metadata[MetadataMain.KEY]['dateCreated'],
"_amounts": _amounts,
"_tokenAddress": "",
"_hash": hash,
"_providerPub": providerKey,
"_receivers": _receivers
}
}
access_service_descriptor = ServiceDescriptor.access_proof_service_descriptor(
access_service_attributes, 'http://localhost:8030')
return register_ddo(metadata, account, providers, auth_service,
[access_service_descriptor])
def fulfill_escrow_payment_condition(keeper,
agreement_id,
cond_ids,
asset,
provider_acc,
service_type=ServiceTypes.ASSET_ACCESS):
escrow_condition_status = keeper.condition_manager.get_condition_state(
cond_ids[2])
if escrow_condition_status != ConditionState.Fulfilled.value:
logger.debug('Fulfilling EscrowPayment condition %s' % agreement_id)
service_agreement = asset.get_service(service_type)
# did_owner = keeper.agreement_manager.get_agreement_did_owner(agreement_id)
access_id, lock_id = cond_ids[:2]
amounts = list(
map(int, service_agreement.get_param_value_by_name('_amounts')))
receivers = to_checksum_addresses(
service_agreement.get_param_value_by_name('_receivers'))
token_address = service_agreement.get_param_value_by_name(
'_tokenAddress')
if token_address is None or len(token_address) == 0:
token_address = keeper.token.address
try:
keeper.escrow_payment_condition.fulfill(
add_0x_prefix(agreement_id), asset.asset_id, amounts,
receivers, keeper.escrow_payment_condition.address,
token_address, lock_id, access_id, provider_acc)
except Exception:
escrow_condition_status = keeper.condition_manager.get_condition_state(
cond_ids[2])
if escrow_condition_status != ConditionState.Fulfilled.value:
logger.error('Error in escrowReward fulfill')
else:
logger.info('The escrowReward condition was already fulfilled')
escrow_condition_status = keeper.condition_manager.get_condition_state(
cond_ids[2])
return escrow_condition_status == ConditionState.Fulfilled.value
def get_registered_compute_ddo(account,
providers=None,
auth_service='PSK-RSA'):
ddo = get_sample_ddo()
metadata = ddo['service'][0]['attributes']
metadata['main']['files'][0][
'url'] = "https://raw.githubusercontent.com/tbertinmahieux/MSongsDB/master/Tasks_Demos" \
"/CoverSongs/shs_dataset_test.txt"
metadata['main']['files'][0]['checksum'] = str(uuid.uuid4())
escrow_payment_condition = ddo['service'][1]['attributes'][
'serviceAgreementTemplate']['conditions'][2]
_amounts = get_param_value_by_name(escrow_payment_condition['parameters'],
'_amounts')
_receivers = to_checksum_addresses(
get_param_value_by_name(escrow_payment_condition['parameters'],
'_receivers'))
compute_service_attributes = {
"main": {
"name": "dataAssetComputeServiceAgreement",
"creator": account.address,
"dataPublished": metadata[MetadataMain.KEY]["dateCreated"],
"price": metadata[MetadataMain.KEY]["price"],
"timeout": 86400,
"_amounts": _amounts,
"_receivers": _receivers,
"provider": {}
}
}
compute_service_descriptor = ServiceDescriptor.compute_service_descriptor(
compute_service_attributes, "http://localhost:8050")
return register_ddo(metadata, account, providers, auth_service,
[compute_service_descriptor])
from nevermined_gateway import constants
from nevermined_gateway import version
from nevermined_gateway.constants import BaseURLs, ConditionState
from nevermined_gateway.util import (build_download_response, check_auth_token,
generate_token, get_buyer_secret_key,
get_provider_account, is_token_valid,
keeper_instance, verify_signature, web3)
from tests.utils import get_registered_ddo, get_proof_ddo, place_order, lock_payment, generate_new_id
PURCHASE_ENDPOINT = BaseURLs.BASE_GATEWAY_URL + '/services/access/initialize'
SERVICE_ENDPOINT = BaseURLs.BASE_GATEWAY_URL + '/services/consume'
amounts = [10, 2]
receivers = to_checksum_addresses([
'0x00Bd138aBD70e2F00903268F3Db08f2D25677C9e',
'0x068ed00cf0441e4829d9784fcbe7b9e26d4bd8d0'
])
def dummy_callback(*_):
pass
def grant_access(agreement_id, ddo, consumer_account, provider_account):
keeper = keeper_instance()
tx_hash = keeper.access_condition.fulfill(agreement_id, ddo.asset_id,
consumer_account.address,
provider_account)
keeper.access_condition.get_tx_receipt(tx_hash)
