def test_creating_ddo_from_scratch():
# create an empty ddo
ddo = DDO()
assert ddo.did is None
assert ddo.asset_id is None
assert ddo.created is not None
did = DID.did("0x99999999999999999")
ddo.assign_did(did)
assert ddo.did == did
pub_acc = get_publisher_account()
ddo.add_service(TEST_SERVICE_TYPE, TEST_SERVICE_URL)
# add a proof to the first public_key/authentication
ddo.add_proof('checksum', pub_acc)
ddo_text_proof = ddo.as_text()
assert ddo_text_proof
pub_acc = get_publisher_account()
assert not ddo.public_keys
ddo.add_public_key(did, pub_acc.address)
assert len(ddo.public_keys) == 1
assert ddo.get_public_key(0) == ddo.public_keys[0]
with pytest.raises(IndexError):
ddo.get_public_key(1)
assert ddo.get_public_key(did) == ddo.public_keys[0]
assert ddo.get_public_key('0x32233') is None
assert not ddo.authentications
ddo.add_authentication(did, '')
assert len(ddo.authentications) == 1
def register_ddo(metadata,
account,
providers,
auth_service,
additional_service_descriptors,
royalties=None,
cap=None,
mint=0):
keeper = keeper_instance()
metadata_api = Metadata('http://172.17.0.1:5000')
ddo = DDO()
ddo_service_endpoint = metadata_api.get_service_endpoint()
metadata_service_desc = ServiceDescriptor.metadata_service_descriptor(
metadata, ddo_service_endpoint)
authorization_service_attributes = {
"main": {
"service": auth_service,
"publicKey": "0xd7"
}
}
service_descriptors = [
ServiceDescriptor.authorization_service_descriptor(
authorization_service_attributes, 'http://localhost:12001')
]
service_descriptors += [metadata_service_desc]
service_descriptors += additional_service_descriptors
services = ServiceFactory.build_services(service_descriptors)
checksums = dict()
for service in services:
try:
checksums[str(service.index)] = checksum(service.main)
except Exception as e:
pass
# Adding proof to the ddo.
ddo.add_proof(checksums, account)
did_seed = checksum(ddo.proof['checksum'])
asset_id = keeper.did_registry.hash_did(did_seed, account.address)
ddo._did = DID.did(asset_id)
did = ddo._did
for service in services:
if service.type == ServiceTypes.ASSET_ACCESS or service.type == ServiceTypes.NFT_ACCESS or service.type == ServiceTypes.ASSET_ACCESS_PROOF:
access_service = ServiceFactory.complete_access_service(
did, service.service_endpoint, service.attributes,
keeper.access_template.address,
keeper.escrow_payment_condition.address, service.type)
ddo.add_service(access_service)
elif service.type == ServiceTypes.CLOUD_COMPUTE:
compute_service = ServiceFactory.complete_compute_service(
did, service.service_endpoint, service.attributes,
keeper.compute_execution_condition.address,
keeper.escrow_payment_condition.address)
ddo.add_service(compute_service)
elif service.type == ServiceTypes.NFT_SALES:
nft_sales_service = ServiceFactory.complete_nft_sales_service(
did, service.service_endpoint, service.attributes,
keeper.nft_sales_template.address,
keeper.escrow_payment_condition.address, service.type)
ddo.add_service(nft_sales_service)
else:
ddo.add_service(service)
ddo.proof['signatureValue'] = keeper.sign_hash(did_to_id_bytes(did),
account)
ddo.add_public_key(did, account.address)
ddo.add_authentication(did, PUBLIC_KEY_TYPE_RSA)
try:
_oldddo = metadata_api.get_asset_ddo(ddo.did)
if _oldddo:
metadata_api.retire_asset_ddo(ddo.did)
except ValueError:
pass
if 'files' in metadata['main']:
if auth_service == ServiceAuthorizationTypes.SECRET_STORE:
encrypted_files = do_secret_store_encrypt(
remove_0x_prefix(ddo.asset_id),
json.dumps(metadata['main']['files']), account, get_config())
elif auth_service == ServiceAuthorizationTypes.PSK_RSA:
encrypted_files, public_key = rsa_encryption_from_file(
json.dumps(metadata['main']['files']),
get_rsa_public_key_file())
else:
encrypted_files, public_key = ecdsa_encryption_from_file(
json.dumps(metadata['main']['files']), get_provider_key_file(),
get_provider_password())
_files = metadata['main']['files']
# only assign if the encryption worked
if encrypted_files:
index = 0
for file in metadata['main']['files']:
file['index'] = index
index = index + 1
del file['url']
metadata['encryptedFiles'] = encrypted_files
ddo_with_did = DDO(did,
json_text=ddo.as_text().replace('/{did}', '/' + did))
ddo_service_endpoint = ddo_service_endpoint.replace('/{did}', '/' + did)
if mint > 0 or royalties is not None or cap is not None:
keeper.did_registry.register_mintable_did(
did_seed,
checksum=web3().toBytes(hexstr=ddo.asset_id),
url=ddo_service_endpoint,
cap=cap,
royalties=royalties,
account=account,
providers=providers)
if mint > 0:
keeper.did_registry.mint(ddo.asset_id, mint, account=account)
else:
keeper_instance().did_registry.register(
did_seed,
checksum=web3().toBytes(hexstr=ddo.asset_id),
url=ddo_service_endpoint,
account=account,
providers=providers)
metadata_api.publish_asset_ddo(ddo_with_did)
return ddo_with_did