async def handle(self, context: RequestContext, responder: BaseResponder): """Handle received get request.""" ledger: BaseLedger = await context.inject(BaseLedger, required=False) if not ledger or ledger.LEDGER_TYPE != 'indy': report = ProblemReport( explain_ltxt='Invalid ledger.', who_retries='none' ) report.assign_thread_from(context.message) await responder.send_reply(report) return taa_info = await ledger.get_txn_author_agreement() acceptance = await ledger.get_latest_txn_author_acceptance() if taa_info['taa_required'] and not acceptance: needed = True elif acceptance and acceptance['digest'] != taa_info['taa_record']['digest']: needed = True else: needed = False result = Taa( version=taa_info['taa_record']['version'], text=taa_info['taa_record']['text'], needed=needed ) result.assign_thread_from(context.message) await responder.send_reply(result)
async def handle(self, context: RequestContext, responder: BaseResponder): """Handle static connection get list request.""" connection_mgr = ConnectionManager(context) wallet: BaseWallet = await context.inject(BaseWallet) try: tag_filter = dict( filter(lambda item: item[1] is not None, { 'initiator': context.message.initiator, 'invitation_key': context.message.invitation_key, 'my_did': context.message.my_did, 'invitation_mode': ConnectionRecord.INVITATION_MODE_STATIC, 'their_did': context.message.their_did, 'their_role': context.message.their_role }.items()) ) records = await ConnectionRecord.query(context, tag_filter) except StorageNotFoundError: report = ProblemReport( explain_ltxt='Connection not found.', who_retries='none' ) report.assign_thread_from(context.message) await responder.send_reply(report) return def flatten_target(connection, target, my_info): """Map for flattening results.""" return { 'connection_id': connection.connection_id, 'their_info': { 'label': target.label, 'did': target.did, 'vk': target.recipient_keys[0], 'endpoint': target.endpoint }, 'my_info': { 'did': my_info.did, 'vk': my_info.verkey, 'endpoint': context.settings.get("default_endpoint") } } targets = [] my_info = [] for record in records: targets.append( await connection_mgr.get_connection_target(record) ) my_info.append(await wallet.get_local_did(record.my_did)) results = list(map( flatten_target, records, targets, my_info )) static_connections = StaticConnectionList(results=results) static_connections.assign_thread_from(context.message) await responder.send_reply(static_connections)
async def handle(self, context: RequestContext, responder: BaseResponder): """Handle received send requests.""" # pylint: disable=protected-access try: connection = await ConnectionRecord.retrieve_by_id( context, context.message.connection_id) except StorageNotFoundError: report = ProblemReport(explain_ltxt='Connection not found.', who_retries='none') report.assign_thread_from(context.message) await responder.send_reply(report) return msg = BasicMessage(content=context.message.content, localization=LocalizationDecorator(locale='en')) await responder.send(msg, connection_id=connection.connection_id) record = BasicMessageRecord( connection_id=context.message.connection_id, message_id=msg._id, sent_time=msg.sent_time, content=msg.content, state=BasicMessageRecord.STATE_SENT) await record.save(context, reason='Message sent.') sent_msg = Sent(connection_id=connection.connection_id, message=record) sent_msg.assign_thread_from(context.message) await responder.send_reply(sent_msg)
async def setup( context: InjectionContext, protocol_registry: ProblemReport = None ): """Setup the basicmessage plugin.""" if not protocol_registry: protocol_registry = await context.inject(ProtocolRegistry) protocol_registry.register_message_types( MESSAGE_TYPES )
async def setup(context: InjectionContext, protocol_registry: ProblemReport = None): """Load plugin.""" # Load in libsovtoken cdll.LoadLibrary(LIBRARY).sovtoken_init() if not protocol_registry: protocol_registry = await context.inject(ProtocolRegistry) protocol_registry.register_message_types(MESSAGE_TYPES)
async def handle(self, context: RequestContext, responder: BaseResponder): """Handle get fees.""" ledger: BaseLedger = await context.inject(BaseLedger) if context.message.method != SOV_METHOD: report = ProblemReport( explain_ltxt=('Method "{}" is not supported.'.format( context.message.method)), who_retries='none') report.assign_thread_from(context.message) await responder.send_reply(report) return try: async with ledger: xfer_auth = await get_transfer_auth(ledger) except (LedgerError, PaymentError) as err: report = ProblemReport(explain_ltxt=(err), who_retries='none') await responder.send_reply(report) return except IndyError as err: # TODO: Remove when IndyErrorHandler bug is fixed. # Likely to be next ACA-Py release. message = 'Unexpected IndyError while retrieving transfer fee' if hasattr(err, 'message'): message += ': {}'.format(err.message) report = ProblemReport(explain_ltxt=(message), who_retries='none') await responder.send_reply(report) return fees = Fees(total=sovatoms_to_tokens(xfer_auth['price'])) fees.assign_thread_from(context.message) await responder.send_reply(fees)
async def _wrapped(handler, context: RequestContext, responder: BaseResponder): if not context.connection_record \ or context.connection_record.their_role != role: report = ProblemReport( explain_ltxt='This connection is not authorized to perform' ' the requested action.', who_retries='none') report.assign_thread_from(context.message) await responder.send_reply(report) return return await func(handler, context, responder)
async def handle(self, context: RequestContext, responder: BaseResponder): """Handle delete connection request.""" if context.message.connection_id == \ context.connection_record.connection_id: report = ProblemReport( explain_ltxt='Current connection cannot be deleted.', who_retries='none') report.assign_thread_from(context.message) await responder.send_reply(report) return try: connection = await ConnectionRecord.retrieve_by_id( context, context.message.connection_id) except StorageNotFoundError: report = ProblemReport(explain_ltxt='Connection not found.', who_retries='none') report.assign_thread_from(context.message) await responder.send_reply(report) return await connection.delete_record(context) ack = ConnectionAck() ack.assign_thread_from(context.message) await responder.send_reply(ack)
async def handle(self, context: RequestContext, responder: BaseResponder): """Handle update connection request.""" try: connection = await ConnectionRecord.retrieve_by_id( context, context.message.connection_id) except StorageNotFoundError: report = ProblemReport(explain_ltxt='Connection not found.', who_retries='none') report.assign_thread_from(context.message) await responder.send_reply(report) new_label = context.message.label or connection.their_label connection.their_label = new_label new_role = context.message.role or connection.their_role connection.their_role = new_role await connection.save(context, reason="Update request received.") conn_response = Connection(connection=connection) conn_response.assign_thread_from(context.message) await responder.send_reply(conn_response)
async def handle(self, context: RequestContext, responder: BaseResponder): """Handle received address list requests.""" if context.message.method and context.message.method != SOV_METHOD: report = ProblemReport( explain_ltxt=('Method "{}" is not supported.'.format( context.message.method)), who_retries='none') report.assign_thread_from(context.message) await responder.send_reply(report) return ledger: BaseLedger = await context.inject(BaseLedger) try: addresses = json.loads(await payment.list_payment_addresses( ledger.wallet.handle)) async with ledger: address_results = [] for address in addresses: balance = 0 sources = [] async for source in get_sources(ledger, address): balance += source['amount'] sources.append(source) address_results.append({ 'address': address, 'method': SOV_METHOD, 'balance': sovatoms_to_tokens(balance), 'raw_repr': { 'sources': sources } }) except (LedgerError, PaymentError) as err: report = ProblemReport(explain_ltxt=(err), who_retries='none') await responder.send_reply(report) return except IndyError as err: # TODO: Remove when IndyErrorHandler bug is fixed. # Likely to be next ACA-Py release. message = 'Unexpected IndyError while retrieving addresses' if hasattr(err, 'message'): message += ': {}'.format(err.message) report = ProblemReport(explain_ltxt=(message), who_retries='none') await responder.send_reply(report) return result = AddressList(addresses=address_results) result.assign_thread_from(context.message) await responder.send_reply(result)
async def handle(self, context: RequestContext, responder: BaseResponder): """Handle received send presentation proposal request.""" connection_id = str(context.message.connection_id) try: connection_record = await ConnectionRecord.retrieve_by_id( context, connection_id ) except StorageNotFoundError: report = ProblemReport( explain_ltxt='Connection not found.', who_retries='none' ) report.assign_thread_from(context.message) await responder.send_reply(report) return if not connection_record.is_ready: report = ProblemReport( explain_ltxt='Connection invalid.', who_retries='none' ) report.assign_thread_from(context.message) await responder.send_reply(report) return comment = context.message.comment # Aries#0037 calls it a proposal in the proposal struct but it's of type preview presentation_proposal = PresentationProposal( comment=comment, presentation_proposal=context.message.presentation_proposal ) auto_present = ( context.message.auto_present or context.settings.get("debug.auto_respond_presentation_request") ) presentation_manager = PresentationManager(context) presentation_exchange_record = ( await presentation_manager.create_exchange_for_proposal( connection_id=connection_id, presentation_proposal_message=presentation_proposal, auto_present=auto_present ) ) await responder.send(presentation_proposal, connection_id=connection_id) pres_exchange = PresExchange(**presentation_exchange_record.serialize()) pres_exchange.assign_thread_from(context.message) await responder.send_reply(pres_exchange)
async def handle(self, context: RequestContext, responder: BaseResponder): """Handle received send proposal request.""" connection_id = str(context.message.connection_id) credential_definition_id = context.message.credential_definition_id comment = context.message.comment credential_manager = CredentialManager(context) try: connection_record = await ConnectionRecord.retrieve_by_id( context, connection_id ) except StorageNotFoundError: report = ProblemReport( explain_ltxt='Connection not found.', who_retries='none' ) report.assign_thread_from(context.message) await responder.send_reply(report) return if not connection_record.is_ready: report = ProblemReport( explain_ltxt='Connection invalid.', who_retries='none' ) report.assign_thread_from(context.message) await responder.send_reply(report) return credential_exchange_record = await credential_manager.create_proposal( connection_id, comment=comment, credential_preview=context.message.credential_proposal, credential_definition_id=credential_definition_id ) await responder.send( CredentialProposal( comment=context.message.comment, credential_proposal=context.message.credential_proposal, cred_def_id=context.message.credential_definition_id ), connection_id=connection_id ) cred_exchange = CredExchange(**credential_exchange_record.serialize()) cred_exchange.assign_thread_from(context.message) await responder.send_reply(cred_exchange)
async def handle(self, context: RequestContext, responder: BaseResponder): """Handle received presentation request request.""" connection_id = str(context.message.connection_id) try: connection_record = await ConnectionRecord.retrieve_by_id( context, connection_id) except StorageNotFoundError: report = ProblemReport(explain_ltxt='Connection not found.', who_retries='none') report.assign_thread_from(context.message) await responder.send_reply(report) return if not connection_record.is_ready: report = ProblemReport(explain_ltxt='Connection invalid.', who_retries='none') report.assign_thread_from(context.message) await responder.send_reply(report) return comment = context.message.comment indy_proof_request = context.message.proof_request if not indy_proof_request.get('nonce'): indy_proof_request['nonce'] = str(uuid4().int) presentation_request_message = PresentationRequest( comment=comment, request_presentations_attach=[ AttachDecorator.from_indy_dict(indy_proof_request) ]) presentation_manager = PresentationManager(context) presentation_exchange_record = ( await presentation_manager.create_exchange_for_request( connection_id=connection_id, presentation_request_message=presentation_request_message)) await responder.send(presentation_request_message, connection_id=connection_id) pres_exchange = IssuerPresExchange( **presentation_exchange_record.serialize()) pres_exchange.assign_thread_from(context.message) await responder.send_reply(pres_exchange)
async def handle(self, context: RequestContext, responder: BaseResponder): """Handle received send cred def request.""" ledger: BaseLedger = await context.inject(BaseLedger) # If no schema record, make one try: schema_record = await SchemaRecord.retrieve_by_schema_id( context, schema_id=context.message.schema_id) except StorageNotFoundError: # Schema will be cached so retrieving here is not # any less efficient (schema is retrieved in # send_credential_definition). async with ledger: schema = await ledger.get_schema(context.message.schema_id) schema_record = SchemaRecord(schema_id=schema['id'], schema_name=schema['name'], schema_version=schema['version'], attributes=schema['attrNames'], state=SchemaRecord.STATE_WRITTEN, author=SchemaRecord.AUTHOR_OTHER) await schema_record.save(context, reason='Retrieved from ledger') try: async with ledger: credential_definition_id = await shield( ledger.send_credential_definition( context.message.schema_id, tag='{}_{}'.format(schema_record.schema_name, schema_record.schema_version))) except Exception as err: report = ProblemReport( explain_ltxt='Failed to send to ledger; Error: {}'.format(err), who_retries='none') await responder.send_reply(report) return cred_def_record = CredDefRecord(cred_def_id=credential_definition_id, schema_id=context.message.schema_id, attributes=list( map(canon, schema_record.attributes)), state=CredDefRecord.STATE_WRITTEN, author=CredDefRecord.AUTHOR_SELF) await cred_def_record.save( context, reason="Committed credential definition to ledger") result = CredDefID(cred_def_id=credential_definition_id) result.assign_thread_from(context.message) await responder.send_reply(result)
async def handle(self, context: RequestContext, responder: BaseResponder): """Handle received send request.""" comment = context.message.comment connection_id = str(context.message.connection_id) preview_spec = context.message.credential_proposal try: connection_record = await ConnectionRecord.retrieve_by_id( context, connection_id) except StorageNotFoundError: report = ProblemReport(explain_ltxt='Connection not found.', who_retries='none') report.assign_thread_from(context.message) await responder.send_reply(report) return if not connection_record.is_ready: report = ProblemReport(explain_ltxt='Connection invalid.', who_retries='none') report.assign_thread_from(context.message) await responder.send_reply(report) return credential_proposal = CredentialProposal( comment=comment, credential_proposal=preview_spec, **{ t: getattr(context.message, t) for t in CRED_DEF_TAGS if hasattr(context.message, t) }, ) credential_manager = CredentialManager(context) cred_exchange_record, cred_offer_message = \ await credential_manager.prepare_send( connection_id, credential_proposal=credential_proposal ) await responder.send(cred_offer_message, connection_id=cred_exchange_record.connection_id) cred_exchange = IssuerCredExchange(**cred_exchange_record.serialize()) cred_exchange.assign_thread_from(context.message) await responder.send_reply(cred_exchange)
async def handle(self, context: RequestContext, responder: BaseResponder): """Handle payment""" ledger: BaseLedger = await context.inject(BaseLedger) if context.message.method != SOV_METHOD: report = ProblemReport( explain_ltxt=('Method "{}" is not supported.'.format( context.message.method)), who_retries='none') report.assign_thread_from(context.message) await responder.send_reply(report) return async with ledger: try: fee = (await get_transfer_auth(ledger))['price'] inputs, outputs = await prepare_payment( ledger, context.message.from_address, context.message.to_address, tokens_to_sovatoms(context.message.amount), fee) receipts = await make_payment(ledger, inputs, outputs) except (LedgerError, PaymentError) as err: report = ProblemReport(explain_ltxt=(err), who_retries='none') await responder.send_reply(report) return except IndyError as err: # TODO: Remove when IndyErrorHandler bug is fixed. # Likely to be next ACA-Py release. message = 'Unexpected IndyError while making payment' if hasattr(err, 'message'): message += ': {}'.format(err.message) report = ProblemReport(explain_ltxt=(message), who_retries='none') await responder.send_reply(report) return completed = TransferComplete(from_address=context.message.from_address, to_address=context.message.to_address, amount=context.message.amount, fees=sovatoms_to_tokens(fee), method=SOV_METHOD, raw_repr=receipts) completed.assign_thread_from(context.message) await responder.send_reply(completed)
async def handle(self, context: RequestContext, responder: BaseResponder): """Handle taa acceptance messages.""" ledger: BaseLedger = await context.inject(BaseLedger, required=False) if not ledger or ledger.LEDGER_TYPE != 'indy': report = ProblemReport( explain_ltxt='Invalid ledger.', who_retries='none' ) report.assign_thread_from(context.message) await responder.send_reply(report) return taa_record = { 'version': context.message.version, 'text': context.message.text, 'digest': ledger.taa_digest( context.message.version, context.message.text ) } try: await ledger.accept_txn_author_agreement( taa_record, context.message.mechanism ) except Exception as err: report = ProblemReport( explain_ltxt='An error occured while attempting to accept' ' the Transaction Author Agreement: {}'.format( err ), who_retries='none' ) report.assign_thread_from(context.message) await responder.send_reply(report) return result = Accepted() result.assign_thread_from(context.message) await responder.send_reply(result)
async def handle(self, context: RequestContext, responder: BaseResponder): """Handle received create address requests.""" wallet: BaseWallet = await context.inject(BaseWallet) ledger: BaseLedger = await context.inject(BaseLedger) if context.message.method != SOV_METHOD: report = ProblemReport( explain_ltxt=('Method "{}" is not supported.'.format( context.message.method)), who_retries='none') report.assign_thread_from(context.message) await responder.send_reply(report) return if context.message.seed and len(context.message.seed) < 32: report = ProblemReport( explain_ltxt=('Seed must be 32 characters in length'), who_retries='none') report.assign_thread_from(context.message) await responder.send_reply(report) return try: address_str = await payment.create_payment_address( wallet.handle, SOV_METHOD, json.dumps({'seed': context.message.seed})) except IndyError as err: message = 'Failed to create payment address' if hasattr(err, 'message'): message += ': {}'.format(err.message) report = ProblemReport(explain_ltxt=(message), who_retries='none') await responder.send_reply(report) return try: async with ledger: balance = 0 sources = [] async for source in get_sources(ledger, address_str): balance += source['amount'] sources.append(source) except (LedgerError, PaymentError) as err: report = ProblemReport(explain_ltxt=(err), who_retries='none') await responder.send_reply(report) return except IndyError as err: # TODO: Remove when IndyErrorHandler bug is fixed. # Likely to be next ACA-Py release. message = 'Unexpected IndyError while retrieving address balances' if hasattr(err, 'message'): message += ': {}'.format(err.message) report = ProblemReport(explain_ltxt=(message), who_retries='none') await responder.send_reply(report) return address = Address( address=address_str, method=SOV_METHOD, balance=sovatoms_to_tokens(balance), ) address.assign_thread_from(context.message) await responder.send_reply(address) return