Remove issaunce protocol 'actions' concept

Signed-off-by: Patrik Stas <patrik.stas@absa.africa>

aries_vcx/src/handlers/issuance/holder.rs

@@ -1,21 +1,19 @@
-use std::collections::HashMap;
+use std::sync::Arc;
 
+use aries_vcx_core::anoncreds::base_anoncreds::BaseAnonCreds;
+use aries_vcx_core::ledger::base_ledger::AnoncredsLedgerRead;
+use aries_vcx_core::wallet::base_wallet::BaseWallet;
 use messages::msg_fields::protocols::cred_issuance::issue_credential::IssueCredential;
 use messages::msg_fields::protocols::cred_issuance::offer_credential::OfferCredential;
 use messages::msg_fields::protocols::cred_issuance::propose_credential::ProposeCredential;
+use messages::msg_fields::protocols::cred_issuance::CredentialIssuance;
 use messages::msg_fields::protocols::revocation::revoke::Revoke;
 use messages::AriesMessage;
-use std::sync::Arc;
-
-use aries_vcx_core::anoncreds::base_anoncreds::BaseAnonCreds;
-use aries_vcx_core::ledger::base_ledger::AnoncredsLedgerRead;
-use aries_vcx_core::wallet::base_wallet::BaseWallet;
 
 use crate::common::credentials::get_cred_rev_id;
 use crate::errors::error::prelude::*;
 use crate::handlers::connection::mediated_connection::MediatedConnection;
 use crate::handlers::revocation_notification::receiver::RevocationNotificationReceiver;
-use crate::protocols::issuance::actions::CredentialIssuanceAction;
 use crate::protocols::issuance::holder::state_machine::{HolderSM, HolderState};
 use crate::protocols::SendClosure;
 
@@ -192,12 +190,14 @@ impl Holder {
  &mut self,
  ledger: &Arc<dyn AnoncredsLedgerRead>,
  anoncreds: &Arc<dyn BaseAnonCreds>,
- cim: CredentialIssuanceAction,
+ message: AriesMessage,
  send_message: Option<SendClosure>,
  ) -> VcxResult<()> {
- let holder_sm = match cim {
- CredentialIssuanceAction::CredentialOffer(offer) => self.holder_sm.clone().receive_offer(offer)?,
- CredentialIssuanceAction::Credential(credential) => {
+ let holder_sm = match message {
+ AriesMessage::CredentialIssuance(CredentialIssuance::OfferCredential(offer)) => {
+ self.holder_sm.clone().receive_offer(offer)?
+ }
+ AriesMessage::CredentialIssuance(CredentialIssuance::IssueCredential(credential)) => {
  let send_message = send_message.ok_or(AriesVcxError::from_msg(
  AriesVcxErrorKind::InvalidState,
  "Attempted to call undefined send_message callback",
@@ -207,9 +207,7 @@ impl Holder {
  .receive_credential(ledger, anoncreds, credential, send_message)
  .await?
  }
- CredentialIssuanceAction::ProblemReport(problem_report) => {
- self.holder_sm.clone().receive_problem_report(problem_report)?
- }
+ AriesMessage::ReportProblem(report) => self.holder_sm.clone().receive_problem_report(report)?,
  _ => self.holder_sm.clone(),
  };
  self.holder_sm = holder_sm;

aries_vcx/src/handlers/issuance/issuer.rs

@@ -5,17 +5,19 @@ use messages::misc::MimeType;
 use messages::msg_fields::protocols::cred_issuance::ack::AckCredential;
 use messages::msg_fields::protocols::cred_issuance::propose_credential::ProposeCredential;
 use messages::msg_fields::protocols::cred_issuance::request_credential::RequestCredential;
-use messages::msg_fields::protocols::cred_issuance::{CredentialAttr, CredentialPreview};
+use messages::msg_fields::protocols::cred_issuance::{CredentialAttr, CredentialIssuance, CredentialPreview};
 use messages::AriesMessage;
 use std::sync::Arc;
 
 use aries_vcx_core::anoncreds::base_anoncreds::BaseAnonCreds;
 use aries_vcx_core::ledger::base_ledger::AnoncredsLedgerRead;
+use messages::msg_fields::protocols::notification::Notification;
+use messages::msg_fields::protocols::report_problem::ProblemReport;
+use messages::msg_parts::MsgParts;
 
 use crate::errors::error::prelude::*;
 use crate::handlers::revocation_notification::sender::RevocationNotificationSender;
 use crate::handlers::util::OfferInfo;
-use crate::protocols::issuance::actions::CredentialIssuanceAction;
 use crate::protocols::issuance::issuer::state_machine::{IssuerSM, IssuerState, RevocationInfoV1};
 use crate::protocols::revocation_notification::sender::state_machine::SenderConfigBuilder;
 use crate::protocols::SendClosure;
@@ -284,15 +286,56 @@ impl Issuer {
  self.issuer_sm.is_revoked(ledger).await
  }
 
- pub async fn process_aries_msg(&mut self, action: CredentialIssuanceAction) -> VcxResult<()> {
- let issuer_sm = match action {
- CredentialIssuanceAction::CredentialProposal(proposal) => {
+ pub async fn receive_proposal(&mut self, proposal: ProposeCredential) -> VcxResult<()> {
+ self.issuer_sm = self.issuer_sm.clone().receive_proposal(proposal)?;
+ Ok(())
+ }
+
+ pub async fn receive_request(&mut self, request: RequestCredential) -> VcxResult<()> {
+ self.issuer_sm = self.issuer_sm.clone().receive_request(request)?;
+ Ok(())
+ }
+
+ pub async fn receive_ack(&mut self, ack: AckCredential) -> VcxResult<()> {
+ self.issuer_sm = self.issuer_sm.clone().receive_ack(ack)?;
+ Ok(())
+ }
+
+ pub async fn receive_problem_report(&mut self, problem_report: ProblemReport) -> VcxResult<()> {
+ self.issuer_sm = self.issuer_sm.clone().receive_problem_report(problem_report)?;
+ Ok(())
+ }
+
+ // todo: will ultimately end up in generic SM layer
+ pub async fn process_aries_msg(&mut self, msg: AriesMessage) -> VcxResult<()> {
+ let issuer_sm = match msg {
+ AriesMessage::CredentialIssuance(CredentialIssuance::ProposeCredential(proposal)) => {
  self.issuer_sm.clone().receive_proposal(proposal)?
  }
- CredentialIssuanceAction::CredentialRequest(request) => self.issuer_sm.clone().receive_request(request)?,
- CredentialIssuanceAction::CredentialAck(ack) => self.issuer_sm.clone().receive_ack(ack)?,
- CredentialIssuanceAction::ProblemReport(problem_report) => {
- self.issuer_sm.clone().receive_problem_report(problem_report)?
+ AriesMessage::CredentialIssuance(CredentialIssuance::RequestCredential(request)) => {
+ self.issuer_sm.clone().receive_request(request)?
+ }
+ AriesMessage::CredentialIssuance(CredentialIssuance::Ack(ack)) => {
+ self.issuer_sm.clone().receive_ack(ack)?
+ }
+ AriesMessage::ReportProblem(report) => self.issuer_sm.clone().receive_problem_report(report)?,
+ AriesMessage::Notification(Notification::ProblemReport(report)) => {
+ let MsgParts {
+ id,
+ content,
+ decorators,
+ } = report;
+ let report = ProblemReport::with_decorators(id, content.0, decorators);
+ self.issuer_sm.clone().receive_problem_report(report)?
+ }
+ AriesMessage::CredentialIssuance(CredentialIssuance::ProblemReport(report)) => {
+ let MsgParts {
+ id,
+ content,
+ decorators,
+ } = report;
+ let report = ProblemReport::with_decorators(id, content.0, decorators);
+ self.issuer_sm.clone().receive_problem_report(report)?
  }
  _ => self.issuer_sm.clone(),
  };

aries_vcx/src/handlers/issuance/mediated_issuer.rs

@@ -33,6 +33,7 @@ pub async fn issuer_update_with_mediator(
  Ok(sm.get_state())
 }
 
+#[allow(clippy::unwrap_used)]
 pub fn issuer_find_messages_to_handle(
  sm: &Issuer,
  messages: HashMap<String, AriesMessage>,

aries_vcx/src/protocols/issuance/holder/state_machine.rs

@@ -24,13 +24,11 @@ use crate::errors::error::prelude::*;
 use crate::global::settings;
 use crate::handlers::util::{get_attach_as_string, make_attach_from_str, AttachmentId, Status};
 use crate::protocols::common::build_problem_report_msg;
-use crate::protocols::issuance::actions::CredentialIssuanceAction;
 use crate::protocols::issuance::holder::states::finished::FinishedHolderState;
 use crate::protocols::issuance::holder::states::initial::InitialHolderState;
 use crate::protocols::issuance::holder::states::offer_received::OfferReceivedState;
 use crate::protocols::issuance::holder::states::proposal_sent::ProposalSentState;
 use crate::protocols::issuance::holder::states::request_sent::RequestSentState;
-use crate::protocols::issuance::verify_thread_id;
 use crate::protocols::SendClosure;
 
 #[derive(Serialize, Deserialize, Debug, Clone)]
@@ -149,10 +147,10 @@ impl HolderSM {
  }
 
  pub async fn send_proposal(self, proposal_data: ProposeCredential, send_message: SendClosure) -> VcxResult<Self> {
- verify_thread_id(
- &self.thread_id,
- &CredentialIssuanceAction::CredentialProposalSend(proposal_data.clone()),
- )?;
+ // verify_thread_id(
+ //  &self.thread_id,
+ //  &CredentialIssuanceAction::CredentialProposalSend(proposal_data.clone()),
+ // )?;
  let state = match self.state {
  HolderFullState::Initial(_) => {
  let mut proposal = proposal_data;
@@ -175,10 +173,10 @@ impl HolderSM {
  }
 
  pub fn receive_offer(self, offer: OfferCredential) -> VcxResult<Self> {
- verify_thread_id(
- &self.thread_id,
- &CredentialIssuanceAction::CredentialOffer(offer.clone()),
- )?;
+ // verify_thread_id(
+ //  &self.thread_id,
+ //  &CredentialIssuanceAction::CredentialOffer(offer.clone()),
+ // )?;
  let state = match self.state {
  HolderFullState::ProposalSent(_) => HolderFullState::OfferReceived(OfferReceivedState::new(offer)),
  s => {

aries_vcx/src/protocols/issuance/issuer/state_machine.rs

@@ -27,15 +27,13 @@ use crate::common::credentials::encoding::encode_attributes;
 use crate::common::credentials::is_cred_revoked;
 use crate::errors::error::{AriesVcxError, AriesVcxErrorKind, VcxResult};
 use crate::protocols::common::build_problem_report_msg;
-use crate::protocols::issuance::actions::CredentialIssuanceAction;
 use crate::protocols::issuance::issuer::states::credential_sent::CredentialSentState;
 use crate::protocols::issuance::issuer::states::finished::FinishedState;
 use crate::protocols::issuance::issuer::states::initial::InitialIssuerState;
 use crate::protocols::issuance::issuer::states::offer_sent::OfferSentState;
 use crate::protocols::issuance::issuer::states::offer_set::OfferSetState;
 use crate::protocols::issuance::issuer::states::proposal_received::ProposalReceivedState;
 use crate::protocols::issuance::issuer::states::requested_received::RequestReceivedState;
-use crate::protocols::issuance::verify_thread_id;
 use crate::protocols::SendClosure;
 
 #[derive(Serialize, Deserialize, Debug, Clone)]
@@ -348,21 +346,17 @@ impl IssuerSM {
  }
 
  pub fn receive_proposal(self, proposal: ProposeCredential) -> VcxResult<Self> {
- verify_thread_id(
- &self.thread_id,
- &CredentialIssuanceAction::CredentialProposal(proposal.clone()),
- )?;
+ // verify_thread_id(
+ //  &self.thread_id,
+ //  &CredentialIssuanceAction::CredentialProposal(proposal.clone()),
+ // )?;
  let (state, thread_id) = match self.state {
  IssuerFullState::Initial(_) => {
  let thread_id = proposal.id.to_string();
  let state = IssuerFullState::ProposalReceived(ProposalReceivedState::new(proposal, None));
  (state, thread_id)
  }
  IssuerFullState::OfferSent(_) => {
- verify_thread_id(
- &self.thread_id,
- &CredentialIssuanceAction::CredentialProposal(proposal.clone()),
- )?;
  let state = IssuerFullState::ProposalReceived(ProposalReceivedState::new(proposal, None));
  (state, self.thread_id.clone())
  }
@@ -392,10 +386,10 @@ impl IssuerSM {
  }
 
  pub fn receive_request(self, request: RequestCredential) -> VcxResult<Self> {
- verify_thread_id(
- &self.thread_id,
- &CredentialIssuanceAction::CredentialRequest(request.clone()),
- )?;
+ // verify_thread_id(
+ //  &self.thread_id,
+ //  &CredentialIssuanceAction::CredentialRequest(request.clone()),
+ // )?;
  let state = match self.state {
  IssuerFullState::OfferSent(state_data) => IssuerFullState::RequestReceived((state_data, request).into()),
  s => {
@@ -450,7 +444,7 @@ impl IssuerSM {
  }
 
  pub fn receive_ack(self, ack: AckCredential) -> VcxResult<Self> {
- verify_thread_id(&self.thread_id, &CredentialIssuanceAction::CredentialAck(ack))?;
+ // verify_thread_id(&self.thread_id, &CredentialIssuanceAction::CredentialAck(ack))?;
  let state = match self.state {
  IssuerFullState::CredentialSent(state_data) => IssuerFullState::Finished(state_data.into()),
  s => {
@@ -462,10 +456,10 @@ impl IssuerSM {
  }
 
  pub fn receive_problem_report(self, problem_report: ProblemReport) -> VcxResult<Self> {
- verify_thread_id(
- &self.thread_id,
- &CredentialIssuanceAction::ProblemReport(problem_report.clone()),
- )?;
+ // verify_thread_id(
+ //  &self.thread_id,
+ //  &CredentialIssuanceAction::ProblemReport(problem_report.clone()),
+ // )?;
  let state = match self.state {
  IssuerFullState::OfferSent(state_data) => IssuerFullState::Finished((state_data, problem_report).into()),
  IssuerFullState::CredentialSent(state_data) => IssuerFullState::Finished((state_data).into()),