async def handle_create_invitation(request):
global agent
connection = await agent.admin_POST("/connections/create-invitation")
agent._connection_ready = asyncio.Future()
agent.connection_id = connection["connection_id"]
log_msg("Invitation has been created !!")
return web.json_response(connection["invitation"])
async def input_invitation(self, invite_details: dict, wait: bool = False):
self._connection_ready = asyncio.Future()
with log_timer("Connect duration:"):
connection = await self.receive_invite(invite_details)
log_json(connection, label="Invitation response:")
if wait:
log_msg("Waiting for connection...")
await self.detect_connection()
async def main(start_port: int, show_timing: bool = False):
global agent
genesis = await default_genesis_txns()
if not genesis:
print("Error retrieving ledger genesis transactions")
sys.exit(1)
try:
log_status(
"Provision an agent and wallet, get back configuration details")
agent = MSPAgent(start_port,
start_port + 1,
genesis_data=genesis,
timing=show_timing)
await agent.listen_webhooks(start_port + 2)
# await agent.register_did()
with log_timer("Startup duration:"):
await agent.start_process()
log_msg("Admin url is at:", agent.admin_url)
log_msg("Endpoint url is at:", agent.endpoint)
app = web.Application()
app.add_routes([
web.get('/create_invitation', handle_create_invitation),
web.post('/verify_signature', handle_verify_signature),
web.post('/verify_proof', handle_verify_proof),
])
cors = aiohttp_cors.setup(
app,
defaults={
"*":
aiohttp_cors.ResourceOptions(
allow_credentials=True,
expose_headers="*",
allow_headers="*",
allow_methods="*",
)
},
)
for route in app.router.routes():
cors.add(route)
setup_aiohttp_apispec(app=app,
title="Aries Cloud Agent two",
version="v1",
swagger_path="/api/doc")
app.on_startup.append(on_startup)
return app
except Exception:
log_status(
"Error while provision an agent and wallet, get back configuration details"
)
async def handle_connections(self, message):
conn_id = message["connection_id"]
if message["rfc23_state"] == "invitation-sent":
self.connection_id = conn_id
if conn_id == self.connection_id:
if (message["rfc23_state"] in ["completed", "response-sent"]
and not self._connection_ready.done()):
self.log("Connected")
log_msg("connection id: ", conn_id)
self._connection_ready.set_result(True)
async def handle_present_proof(self, message):
state = message["state"]
presentation_exchange_id = message["presentation_exchange_id"]
presentation_request = message["presentation_request"]
log_msg(
"Presentation: state =",
state,
", presentation_exchange_id =",
presentation_exchange_id,
)
async def main(start_port: int, show_timing: bool = False):
global agent
genesis = await default_genesis_txns()
agent = None
if not genesis:
print("Error retrieving ledger genesis transactions")
sys.exit(1)
try:
agent = CI_MSPAgent(start_port,
start_port + 1,
genesis_data=genesis,
timing=show_timing)
await agent.listen_webhooks(start_port + 2)
await agent.register_did()
with log_timer("Startup duration:"):
await agent.start_process()
log_msg("Admin url is at:", agent.admin_url)
log_msg("Endpoint url is at:", agent.endpoint)
app = web.Application()
app.add_routes([
# These are api's for ci and msp
web.get('/create_invitation', handle_create_invitation),
# These are api's for ci
web.post('/create_schema_cred_def',
handle_create_schema_credential_definition),
web.post('/send_credential_offer', handle_send_credential_offer),
web.get('/issue_credential', handle_issue_credential),
web.get('/get_connection_list', handle_get_connection_list),
web.get('/get_cred_def_list', handle_get_cred_def_list),
#These are the api's for msp
web.post('/verify_signature', handle_verify_signature),
web.post('/verify_proof', handle_verify_proof),
])
cors = aiohttp_cors.setup(
app,
defaults={
"*":
aiohttp_cors.ResourceOptions(
allow_credentials=True,
expose_headers="*",
allow_headers="*",
allow_methods="*",
)
},
)
for route in app.router.routes():
cors.add(route)
return app
except Exception:
print("Error when starting to run server!!")
async def handle_create_invitation(request):
global agent
connection = await agent.admin_POST("/connections/create-invitation")
agent.connection_id = connection["connection_id"]
agent._connection_ready = asyncio.Future()
log_json(connection, label="Invitation response:")
log_msg(json.dumps(connection["invitation"]),
label="Invitation:",
color=None)
return web.json_response(connection["invitation"])
async def main(start_port: int, show_timing: bool = False, container_name: str = "Simple_client"):
global agent
global client_name
genesis = await default_genesis_txns()
if not genesis:
print("Error retrieving ledger genesis transactions")
sys.exit(1)
try:
log_status("Provision an agent and wallet, get back configuration details")
label=container_name
client_name=label
agent = ClientAgent(
label, start_port, start_port + 1, genesis_data=genesis, timing=show_timing
)
await agent.listen_webhooks(start_port + 2)
# await agent.register_did()
with log_timer("Startup duration:"):
await agent.start_process()
log_msg("Admin url is at:", agent.admin_url)
log_msg("Endpoint url is at:", agent.endpoint)
async with aiofile.AIOFile("client_logger.csv", 'w') as afp:
writer = aiofile.Writer(afp)
await writer("")
await afp.fsync()
app = web.Application()
app.add_routes([
web.get('/get_client_name', handle_get_client_name),
web.get('/get_connections', handle_get_connections),
web.post('/input_invitation', handle_input_invitation),
web.post('/sign_message', handle_sign_message),
web.get('/get_signing_did', handle_get_signing_did),
web.get('/readCommentsFromLogger', readCommentsFromLogger),
])
cors = aiohttp_cors.setup(
app,
defaults={
"*": aiohttp_cors.ResourceOptions(
allow_credentials=True,
expose_headers="*",
allow_headers="*",
allow_methods="*",
)
},
)
for route in app.router.routes():
cors.add(route)
return app
except Exception:
print("Error when starting to run server!!")
async def main(start_port: int, show_timing: bool = False):
global agent
genesis = await default_genesis_txns()
agent = None
if not genesis:
print("Error retrieving ledger genesis transactions")
sys.exit(1)
try:
agent = CredentialIssuerAgent(
start_port, start_port + 1, genesis_data=genesis, timing=show_timing
)
await agent.listen_webhooks(start_port + 2)
await agent.register_did()
with log_timer("Startup duration:"):
await agent.start_process()
log_msg("Admin url is at:", agent.admin_url)
log_msg("Endpoint url is at:", agent.endpoint)
async with aiofile.AIOFile("issuer_logger.csv", 'w') as afp:
writer = aiofile.Writer(afp)
await writer("")
await afp.fsync()
app = web.Application()
app.add_routes([
web.get('/create_invitation', handle_create_invitation),
web.post('/create_schema_cred_def', handle_create_schema_credential_definition),
web.post('/send_credential_offer', handle_send_credential_offer),
web.get('/issue_credential', handle_issue_credential),
web.get('/get_connection_list', handle_get_connection_list),
web.get('/get_cred_def_list', handle_get_cred_def_list),
web.get('/readCommentsFromLogger', readCommentsFromLogger),
])
cors = aiohttp_cors.setup(
app,
defaults={
"*": aiohttp_cors.ResourceOptions(
allow_credentials=True,
expose_headers="*",
allow_headers="*",
allow_methods="*",
)
},
)
for route in app.router.routes():
cors.add(route)
return app
except Exception:
print("Error when starting to run server!!")
async def input_invitation(agent):
agent._connection_ready = asyncio.Future()
async for details in prompt_loop("Invite details: "):
b64_invite = None
try:
url = urlparse(details)
query = url.query
if query and "c_i=" in query:
pos = query.index("c_i=") + 4
b64_invite = query[pos:]
elif query and "oob=" in query:
pos = query.index("oob=") + 4
b64_invite = query[pos:]
else:
b64_invite = details
except ValueError:
b64_invite = details
if b64_invite:
try:
padlen = 4 - len(b64_invite) % 4
if padlen <= 2:
b64_invite += "=" * padlen
invite_json = base64.urlsafe_b64decode(b64_invite)
details = invite_json.decode("utf-8")
except binascii.Error:
pass
except UnicodeDecodeError:
pass
if details:
try:
details = json.loads(details)
break
except json.JSONDecodeError as e:
log_msg("Invalid invitation:", str(e))
with log_timer("Connect duration:"):
if "/out-of-band/" in details.get("@type", ""):
connection = await agent.admin_POST(
"/out-of-band/receive-invitation", details
)
else:
connection = await agent.admin_POST(
"/connections/receive-invitation", details
)
agent.connection_id = connection["connection_id"]
log_json(connection, label="Invitation response:")
await agent.detect_connection()
async def main(start_port: int,
show_timing: bool = False,
container_name: str = "Simple_client"):
global temp_message
global temp_data
global agent
genesis = await default_genesis_txns()
if not genesis:
print("Error retrieving ledger genesis transactions")
sys.exit(1)
try:
log_status(
"#7 Provision an agent and wallet, get back configuration details")
label = container_name
agent = ClientAgent(label,
start_port,
start_port + 1,
genesis_data=genesis,
timing=show_timing)
await agent.listen_webhooks(start_port + 2)
with log_timer("Startup duration:"):
await agent.start_process()
log_msg("Admin url is at:", agent.admin_url)
log_msg("Endpoint url is at:", agent.endpoint)
app = web.Application()
app.add_routes([
web.post('/input_invitation', handle_input_invitation),
])
cors = aiohttp_cors.setup(
app,
defaults={
"*":
aiohttp_cors.ResourceOptions(
allow_credentials=True,
expose_headers="*",
allow_headers="*",
allow_methods="*",
)
},
)
for route in app.router.routes():
cors.add(route)
return app
except Exception:
print("Error when starting to run server!!")
async def handle_get_signing_did(request):
log_status("Function for creating and getting common did has been called")
global signing_did
global signing_vk
global agent
if signing_did==None:
result = await agent.admin_POST("/connections/create-signing-did")
log_status("Signing did and verification key created")
log_msg("Singing did : "+str(result['signing_did']))
log_msg("Singing verkey : "+str(result['signing_vk']))
signing_did=result['signing_did']
signing_vk=result['signing_vk']
return web.json_response({"signing_did" : signing_did})
async def input_invitation(agent):
async for details in prompt_loop("Invite details: "):
if details:
try:
json.loads(details)
break
except json.JSONDecodeError as e:
log_msg("Invalid JSON:", str(e))
pass
with log_timer("Connect duration:"):
connection = await agent.admin_POST("/connections/receive-invitation", details)
agent.connection_id = connection["connection_id"]
log_json(connection, label="Invitation response:")
await agent.detect_connection()
async def handle_basicmessages(self, message):
self.log(message)
# self.log("Received message:", message["content"])
if message["connection_id"] in self.trusted_researcher_connection_ids:
self.log("Research is trusted", message["connection_id"])
cwd = os.getcwd()
self.log("Open file")
try:
f = open(cwd + "/model/untrained_model.pt", "wb+")
# self.log(bytes.fromhex(message["content"]))
byte_message = bytes.fromhex(message["content"])
f.write(byte_message)
f.close()
except Exception as e:
self.log("Error writing file", e)
return
self.log("Import file")
self.log("learning")
learnt = await hospital_learn()
self.log("Learnt : ", learnt)
trained_model = None
try:
trained_file = open(cwd + "/model/trained_model.pt", "rb")
self.log("Trained file open")
trained_model = trained_file.read()
trained_file.close()
except:
self.log("Unable to open trained model")
connection_id = message["connection_id"]
log_msg("Connection ID", message["connection_id"])
if trained_model:
await self.admin_POST(
f"/connections/{connection_id}/send-message",
{"content": trained_model.hex()})
else:
self.log(
"Untrusted Researcher - Must first authenticate as being certified by Regulator"
)
async def terminate(self):
"""Shut down any running agents."""
terminated = True
try:
if self.mediator_agent:
log_msg("Shutting down mediator agent ...")
await self.mediator_agent.terminate()
if self.agent:
log_msg("Shutting down agent ...")
await self.agent.terminate()
except Exception:
LOGGER.exception("Error terminating agent:")
terminated = False
await asyncio.sleep(3.0)
return terminated
async def generate_new_connection(agent):
# handle new invitation
with log_timer("Generate invitation duration:"):
# Generate an invitation
log_status(
"#5 Create a connection to alice and print out the invite details"
)
connection = await agent.admin_POST("/connections/create-invitation")
agent.active_connection_id = connection["connection_id"]
agent.connection_list.append(connection["connection_id"])
log_msg("all connections :", agent.connection_list)
log_json(connection, label="Invitation response:")
log_msg("*****************")
log_msg(json.dumps(connection["invitation"]), label="Invitation:", color=None)
log_msg("*****************")
log_msg("Waiting for connection...")
await agent.detect_connection()
async def generate_invitation(
self,
use_did_exchange: bool,
auto_accept: bool = True,
display_qr: bool = False,
wait: bool = False,
):
self._connection_ready = asyncio.Future()
with log_timer("Generate invitation duration:"):
# Generate an invitation
log_status(
"#7 Create a connection to alice and print out the invite details"
)
invi_rec = await self.get_invite(use_did_exchange, auto_accept)
if display_qr:
qr = QRCode(border=1)
qr.add_data(invi_rec["invitation_url"])
log_msg(
"Use the following JSON to accept the invite from another demo agent."
" Or use the QR code to connect from a mobile agent.")
log_msg(json.dumps(invi_rec["invitation"]),
label="Invitation Data:",
color=None)
qr.print_ascii(invert=True)
if wait:
log_msg("Waiting for connection...")
await self.detect_connection()
return invi_rec
async def main(start_port: int, show_timing: bool = False):
genesis = await default_genesis_txns()
if not genesis:
print("Error retrieving ledger genesis transactions")
sys.exit(1)
agent = None
try:
log_status("#7 Provision an agent and wallet, get back configuration details")
agent = AliceAgent(
start_port, start_port + 1, genesis_data=genesis, timing=show_timing
)
await agent.listen_webhooks(start_port + 2)
with log_timer("Startup duration:"):
await agent.start_process()
log_msg("Admin url is at:", agent.admin_url)
log_msg("Endpoint url is at:", agent.endpoint)
log_status("#9 Input faber.py invitation details")
await input_invitation(agent)
async for option in prompt_loop(
"(3) Send Message (4) Input New Invitation (X) Exit? [3/4/X]: "
):
if option is None or option in "xX":
break
elif option == "3":
msg = await prompt("Enter message: ")
if msg:
await agent.admin_POST(
f"/connections/{agent.connection_id}/send-message",
{"content": msg},
)
elif option == "4":
# handle new invitation
log_status("Input new invitation details")
await input_invitation(agent)
if show_timing:
timing = await agent.fetch_timing()
if timing:
for line in agent.format_timing(timing):
log_msg(line)
finally:
terminated = True
try:
if agent:
await agent.terminate()
except Exception:
LOGGER.exception("Error terminating agent:")
terminated = False
await asyncio.sleep(0.1)
if not terminated:
os._exit(1)
async def generate_invitation(agent, use_did_exchange: bool):
agent._connection_ready = asyncio.Future()
with log_timer("Generate invitation duration:"):
# Generate an invitation
log_status(
"#7 Create a connection to alice and print out the invite details")
if use_did_exchange:
invi_rec = await agent.admin_POST(
"/out-of-band/create-invitation",
{"include_handshake": True},
)
else:
invi_rec = await agent.admin_POST("/connections/create-invitation")
qr = QRCode(border=1)
qr.add_data(invi_rec["invitation_url"])
log_msg(
"Use the following JSON to accept the invite from another demo agent."
" Or use the QR code to connect from a mobile agent.")
log_msg(json.dumps(invi_rec["invitation"]),
label="Invitation Data:",
color=None)
qr.print_ascii(invert=True)
log_msg("Waiting for connection...")
await agent.detect_connection()
async def handle_verify_signature(request):
global agent
data = await request.json()
resp = {}
#Check if any attribute not there.
for element in ['message', 'their_did', 'signature']:
if element not in data:
return web.json_response({"status": "Attribute missing"})
#Check if any attribute has not value.
if (data['message'] == None or data['message'] == '') or (
data['their_did'] == None or data['their_did']
== '') or (data['signature'] == None or data['signature'] == ''):
return web.json_response({"status": "Enter valid details"})
message = data['message']
their_did = data['their_did']
signature = data['signature']
log_msg("message : " + message)
log_msg("their_did : " + their_did)
log_msg("signature : " + signature)
try:
temp = signature.encode('iso-8859-15')
temp1 = base64.b64decode(temp)
signature = temp1.decode('utf-8')
except:
return web.json_response({"status": "Invalid signature"})
while True:
verify = await agent.admin_POST("/connections/verify-transaction", {
"message": message,
"their_did": their_did,
"signature": signature
})
if verify['status'] != 'operation not complete':
break
else:
log_status("Still waiting for pool to be closed!!")
if verify['status'] == 'True':
await writeCommentToLogger("Signature verified")
res = await agent.admin_GET(f"/connections",
params={"their_did": their_did})
if res != []:
resp['status'] = "Signature verified"
resp['connection_id'] = res[0]['connection_id']
else:
resp[
'status'] = "Signature verified but not connected to the client agent"
else:
await writeCommentToLogger("Incorrect Signature")
resp['status'] = "not verified"
log_status("The status : " + verify['status'])
return web.json_response(resp)
async def handle_issue_credential(request):
global agent
global issue_message
global temp_conn_id
CRED_PREVIEW_TYPE = (
"did:sov:BzCbsNYhMrjHiqZDTUASHg;spec/issue-credential/1.0/credential-preview"
)
state = issue_message["state"]
credential_exchange_id = issue_message["credential_exchange_id"]
prev_state = agent.cred_state.get(credential_exchange_id)
if prev_state == state:
return # ignore
agent.cred_state[credential_exchange_id] = state
if state == "request_received":
cred_attrs = agent.cred_attrs[
issue_message["credential_definition_id"]]
cred_preview = {
"@type":
CRED_PREVIEW_TYPE,
"attributes": [{
"name": n,
"value": v
} for (n, v) in cred_attrs.items()],
}
res = await agent.admin_POST(
f"/issue-credential/records/{credential_exchange_id}/issue",
{
"comment":
f"Issuing credential, exchange {credential_exchange_id}",
"credential_preview": cred_preview,
},
)
log_status("Credential has been issued!!")
log_msg(res['credential'])
return web.json_response({"status": True})
async def input_invitation(agent_container):
agent_container.agent._connection_ready = asyncio.Future()
async for details in prompt_loop("Invite details: "):
b64_invite = None
try:
url = urlparse(details)
query = url.query
if query and "c_i=" in query:
pos = query.index("c_i=") + 4
b64_invite = query[pos:]
elif query and "oob=" in query:
pos = query.index("oob=") + 4
b64_invite = query[pos:]
else:
b64_invite = details
except ValueError:
b64_invite = details
if b64_invite:
try:
padlen = 4 - len(b64_invite) % 4
if padlen <= 2:
b64_invite += "=" * padlen
invite_json = base64.urlsafe_b64decode(b64_invite)
details = invite_json.decode("utf-8")
except binascii.Error:
pass
except UnicodeDecodeError:
pass
if details:
try:
details = json.loads(details)
break
except json.JSONDecodeError as e:
log_msg("Invalid invitation:", str(e))
with log_timer("Connect duration:"):
connection = await agent_container.input_invitation(details, wait=True)
async def handle_create_schema_credential_definition(request):
global agent
global credDefIdList
data = await request.json()
# Check if data is empty or has the values
if "schema_name" not in data:
return web.json_response({"status" : "Schema name needed"})
if "attributes" not in data:
return web.json_response({"status" : "Attributes needed"})
# Schema name and attributes input validation
if data['schema_name']=='' or data['schema_name']==None:
return web.json_response({"status" : "Enter a valid schema name"})
if data['attributes']=='' or data['attributes']==None:
return web.json_response({"status" : "Enter valid attibutes"})
schema_name = data['schema_name']
attr_list = [element.strip(' ') for element in data['attributes'].split(",")]
version = format(
"%d.%d.%d"
% (
random.randint(1, 101),
random.randint(1, 101),
random.randint(1, 101),
)
)
(schema_id, credential_definition_id) = await agent.register_schema_and_creddef(
schema_name, version, attr_list
)
log_msg("schema has been created !!")
log_msg("Schema and Credential definition has been created !!")
log_msg("Schema id : ", schema_id)
log_msg("Credential definition id : ", credential_definition_id)
credDefIdList.append({
"schema_name" : schema_name,
"credential_definition_id" : credential_definition_id,
"attr_list" : attr_list,
})
await writeCommentToLogger("Schema and credential definition created")
return web.json_response({
"schema_id" : schema_id,
"credential_definition_id" : credential_definition_id
})
async def input_invitation(agent):
async for details in prompt_loop("Invite details: "):
b64_invite = None
try:
url = urlparse(details)
query = url.query
if query and "c_i=" in query:
pos = query.index("c_i=") + 4
b64_invite = query[pos:]
else:
b64_invite = details
except ValueError:
b64_invite = details
if b64_invite:
try:
invite_json = base64.urlsafe_b64decode(b64_invite)
details = invite_json.decode("utf-8")
except binascii.Error:
pass
except UnicodeDecodeError:
pass
if details:
try:
json.loads(details)
break
except json.JSONDecodeError as e:
log_msg("Invalid invitation:", str(e))
with log_timer("Connect duration:"):
connection = await agent.admin_POST("/connections/receive-invitation",
details)
agent.connection_id = connection["connection_id"]
log_json(connection, label="Invitation response:")
await agent.detect_connection()
async def connect():
# Generate an invitation
log_status(
"#5 Create a connection to alice and print out the invite details")
connection = await agent.admin_POST("/connections/create-invitation")
agent.active_connection_id = connection["connection_id"]
agent.connection_list.append(connection["connection_id"])
log_msg("all connections :", agent.connection_list)
log_json(connection, label="Invitation response:")
log_msg("*****************")
log_msg(json.dumps(connection["invitation"]),
label="Invitation:",
color=None)
log_msg("*****************")
agent._connection_ready = asyncio.Future()
return json.dumps(connection["invitation"])
async def handle_create_invitation(request):
with log_timer("Generate invitation duration:"):
log_status(
"#5 Create a connection to alice and print out the invite details"
)
connection = await agent.admin_POST("/connections/create-invitation")
agent.connection_id = connection["connection_id"]
log_json(connection, label="Invitation response:")
log_msg("*****************")
log_msg(json.dumps(connection["invitation"]), label="Invitation:", color=None)
log_msg("*****************")
return web.json_response(connection["invitation"])
async def handle_create_invitation(request):
global agent
log_status("Create invitation has been called !!")
connection = await agent.admin_POST("/connections/create-invitation")
agent.connection_id = connection["connection_id"]
agent._connection_ready = asyncio.Future()
log_json(connection, label="Invitation response:")
log_msg("*****************")
log_msg(json.dumps(connection["invitation"]),
label="Invitation:",
color=None)
log_msg("*****************")
await writeCommentToLogger("Invitation created")
return web.json_response(connection["invitation"])
async def main(start_port: int, show_timing: bool = False):
genesis = await default_genesis_txns()
if not genesis:
print("Error retrieving ledger genesis transactions")
sys.exit(1)
agent = None
try:
log_status(
"#1 Provision an agent and wallet, get back configuration details")
agent = RegulatorAgent(start_port,
start_port + 1,
genesis_data=genesis,
timing=show_timing)
await agent.listen_webhooks(start_port + 2)
await agent.register_did()
with log_timer("Startup duration:"):
await agent.start_process()
log_msg("Admin url is at:", agent.admin_url)
log_msg("Endpoint url is at:", agent.endpoint)
# Create a schema
with log_timer("Publish schema/cred def duration:"):
log_status("#3/4 Create a new schema/cred def on the ledger")
version = format("%d.%d.%d" % (
random.randint(1, 101),
random.randint(1, 101),
random.randint(1, 101),
))
(
_, # schema id
credential_definition_id,
) = await agent.register_schema_and_creddef(
"Certified Researcher schema", version,
["institution", "date"])
# TODO add an additional credential for Student ID
with log_timer("Generate invitation duration:"):
# Generate an invitation
log_status(
"#5 Create a connection to Hospital and print out the invite details"
)
connection = await agent.admin_POST(
"/connections/create-invitation")
agent.active_connection_id = connection["connection_id"]
agent.connection_list.append(connection["connection_id"])
log_json(connection, label="Invitation response:")
log_msg("*****************")
log_msg(json.dumps(connection["invitation"]),
label="Invitation:",
color=None)
log_msg("*****************")
log_msg("Waiting for connection...")
await agent.detect_connection()
async for option in prompt_loop(
"(1) Issue Credential, (2) Create a New Invitation, (X) Exit? [1/2/X] "
):
if option is None or option in "xX":
break
elif option == "1":
log_status("#13 Issue credential offer to X")
today = date.today()
# TODO define attributes to send for credential
agent.cred_attrs[credential_definition_id] = {
# "name": str(credential_definition_id),
"date": str(today),
"institution": "Edinburgh Napier University",
# "age": "24",
}
cred_preview = {
"@type":
CRED_PREVIEW_TYPE,
"attributes":
[{
"name": n,
"value": v
} for (n, v) in
agent.cred_attrs[credential_definition_id].items()],
}
offer_request = {
"connection_id": agent.active_connection_id,
"credential_definition_id": credential_definition_id,
"comment":
f"Offer on cred def id {credential_definition_id}",
"credential_preview": cred_preview,
}
await agent.admin_POST("/issue-credential/send-offer",
offer_request)
elif option == "2":
# handle new invitation
with log_timer("Generate invitation duration:"):
# Generate an invitation
log_status(
"#5 Create a connection to alice and print out the invite details"
)
connection = await agent.admin_POST(
"/connections/create-invitation")
agent.active_connection_id = connection["connection_id"]
agent.connection_list.append(connection["connection_id"])
log_msg("all connections :", agent.connection_list)
log_json(connection, label="Invitation response:")
log_msg("*****************")
log_msg(json.dumps(connection["invitation"]),
label="Invitation:",
color=None)
log_msg("*****************")
agent._connection_ready = asyncio.Future()
log_msg("Waiting for connection...")
await agent.detect_connection()
if show_timing:
timing = await agent.fetch_timing()
if timing:
for line in agent.format_timing(timing):
log_msg(line)
finally:
terminated = True
try:
if agent:
await agent.terminate()
except Exception:
LOGGER.exception("Error terminating agent:")
terminated = False
await asyncio.sleep(0.1)
if not terminated:
os._exit(1)
async def test_main(
start_port: int,
no_auto: bool = False,
revocation: bool = False,
tails_server_base_url: str = None,
show_timing: bool = False,
multitenant: bool = False,
mediation: bool = False,
use_did_exchange: bool = False,
wallet_type: str = None,
):
"""Test to startup a couple of agents."""
faber_container = None
alice_container = None
try:
# initialize the containers
faber_container = AgentContainer(
genesis,
"Faber.agent",
start_port,
no_auto=no_auto,
revocation=revocation,
tails_server_base_url=tails_server_base_url,
show_timing=show_timing,
multitenant=multitenant,
mediation=mediation,
use_did_exchange=use_did_exchange,
wallet_type=wallet_type,
public_did=True,
seed="random",
)
alice_container = AgentContainer(
genesis,
"Alice.agent",
start_port + 10,
no_auto=no_auto,
revocation=False,
show_timing=show_timing,
multitenant=multitenant,
mediation=mediation,
use_did_exchange=use_did_exchange,
wallet_type=wallet_type,
public_did=False,
seed=None,
)
# start the agents - faber gets a public DID and schema/cred def
await faber_container.initialize(
schema_name="degree schema",
schema_attrs=[
"name",
"date",
"degree",
"grade",
],
)
await alice_container.initialize()
# faber create invitation
invite = await faber_container.generate_invitation()
# alice accept invitation
invite_details = invite["invitation"]
connection = await alice_container.input_invitation(invite_details)
# wait for faber connection to activate
await faber_container.detect_connection()
await alice_container.detect_connection()
# TODO faber issue credential to alice
# TODO alice check for received credential
log_msg("Sleeping ...")
await asyncio.sleep(3.0)
except Exception as e:
LOGGER.exception("Error initializing agent:", e)
raise (e)
finally:
terminated = True
try:
# shut down containers at the end of the test
if alice_container:
log_msg("Shutting down alice agent ...")
await alice_container.terminate()
if faber_container:
log_msg("Shutting down faber agent ...")
await faber_container.terminate()
except Exception as e:
LOGGER.exception("Error terminating agent:", e)
terminated = False
await asyncio.sleep(0.1)
if not terminated:
os._exit(1)
await asyncio.sleep(2.0)
os._exit(1)
async def initialize(
self,
the_agent: DemoAgent = None,
schema_name: str = None,
schema_attrs: list = None,
):
"""Startup agent(s), register DID, schema, cred def as appropriate."""
if not the_agent:
log_status(
"#1 Provision an agent and wallet, get back configuration details"
+ (f" (Wallet type: {self.wallet_type})" if self.
wallet_type else ""))
self.agent = AriesAgent(
self.ident,
self.start_port,
self.start_port + 1,
genesis_data=self.genesis_txns,
no_auto=self.no_auto,
tails_server_base_url=self.tails_server_base_url,
timing=self.show_timing,
revocation=self.revocation,
multitenant=self.multitenant,
mediation=self.mediation,
wallet_type=self.wallet_type,
seed=self.seed,
arg_file=self.arg_file,
)
else:
self.agent = the_agent
await self.agent.listen_webhooks(self.start_port + 2)
if self.public_did:
await self.agent.register_did()
with log_timer("Startup duration:"):
await self.agent.start_process()
log_msg("Admin URL is at:", self.agent.admin_url)
log_msg("Endpoint URL is at:", self.agent.endpoint)
if self.mediation:
self.mediator_agent = await start_mediator_agent(
self.start_port + 4, self.genesis_txns)
if not self.mediator_agent:
raise Exception("Mediator agent returns None :-(")
else:
self.mediator_agent = None
if self.multitenant:
# create an initial managed sub-wallet (also mediated)
rand_name = str(random.randint(100_000, 999_999))
await self.agent.register_or_switch_wallet(
self.ident + ".initial." + rand_name,
public_did=self.public_did,
webhook_port=None,
mediator_agent=self.mediator_agent,
)
elif self.mediation:
# we need to pre-connect the agent to its mediator
if not await connect_wallet_to_mediator(self.agent,
self.mediator_agent):
raise Exception("Mediation setup FAILED :-(")
if schema_name and schema_attrs:
# Create a schema/cred def
self.cred_def_id = await self.create_schema_and_cred_def(
schema_name, schema_attrs)
