TECH 292 - Remove SupportedTypes Constraint

README.md

@@ -23,16 +23,14 @@ Here is an example of a credential the Civic Canister can issue:
     "https://www.w3.org/ns/credentials/examples/v2"
   ],
   "id": "urn:uuid:6a9c92a9-2530-4e2b-9776-530467e9bbe0",
-  "type": ["VerifiableCredential", "CivicUniquenessPass"],
+  "type": ["VerifiableCredential", "CivicPass"],
   "issuer": "did:icp:v0:tglqb-kbqlj-to66e-3w5sg-kkz32-c6ffi-nsnta-vj2gf-vdcc5-5rzjk-jae",
   "expiry": "2024-04-04T00:00:00Z",
   "credentialSubject": {
     "id": "did:icp:user-principal",
-    "CivicPass": {
-      "id": "did:example:c276e12ec21ebfeb1f712ebc6f1",
-      "name": "Civic Uniqueness Pass",
-      "expiry": "2024-04-04T00:00:00Z"
-    }
+    "passType": "uniqobk8oGh4XBLMqM68K8M2zNu3CdYX7q5go7whQiv",
+    "status": "ACTIVE",
+    "expirationDate": "2024-12-31T23:59:59Z"
   }
 }
 ```
@@ -80,8 +78,6 @@ To simplify the deployment of the canisters we provide a script `deploy-civic.sh
   ./scripts/deploy-civic.sh local 
   ```
 
-Note: The script stops dfx after it executes. If you want to call your canisters, you have to start it again as `dfx start --background`. 
-
 ### Manual deployment 
 Steps for the manual deployment: 
 1. **Create canisters and start the local Internet Computer replica**:

lib/vc_util/src/issuer_api.rs

@@ -21,10 +21,12 @@ pub struct PrepareCredentialRequest {
 pub enum IssueCredentialError {
     UnknownSubject(String),
     UnauthorizedSubject(String),
+    UnauthorizedIssuer(String),
     InvalidIdAlias(String),
     SignatureNotFound(String),
     Internal(String),
     UnsupportedCredentialSpec(String),
+    CredentialNotFound(String)
 }
 
 #[derive(Clone, Debug, CandidType, Deserialize, Eq, PartialEq)]
@@ -47,14 +49,14 @@ pub struct IssuedCredentialData {
 #[derive(Eq, PartialEq, Clone, Debug, CandidType, Deserialize)]
 pub enum ArgumentValue {
     String(String),
-    Int(i32),
+    Int(i32)
 }
 
 impl Display for ArgumentValue {
     fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
         match &self {
             ArgumentValue::String(s) => write!(f, "'{}'", s),
-            ArgumentValue::Int(i) => write!(f, "{}", i),
+            ArgumentValue::Int(i) => write!(f, "{}", i)
         }
     }
 }
@@ -63,7 +65,7 @@ impl From<ArgumentValue> for Value {
     fn from(argument_value: ArgumentValue) -> Self {
         match argument_value {
             ArgumentValue::String(s) => Value::String(s),
-            ArgumentValue::Int(i) => Value::Number(Number::from(i)),
+            ArgumentValue::Int(i) => Value::Number(Number::from(i))
         }
     }
 }

scripts/deploy-civic.sh

@@ -157,18 +157,8 @@ main() {
       exit 1
     fi
 
-  # Stop the local DFX environment if it was started
-  if [ "$network" = "local" ]; then
-    echo "Stopping local DFX environment..."
-    if ! dfx stop >>$log_file 2>&1; then
-      echo "Error: Failed to stop local DFX environment. Check $log_file for details."
-      exit 1
-    fi
-  fi
-
   echo "Deployment completed successfully."
   echo "Please check deploy.log for details."
-
 }
 
 # Execute main function with provided network argument

src/civic_canister_backend/src/consent_message.rs

@@ -4,59 +4,42 @@ use std::fmt::{Display, Formatter};
 use candid::candid_method;
 use ic_cdk_macros::update;
 use lazy_static::lazy_static;
-use crate::credential::{SupportedCredentialType, verify_credential_spec};
 use vc_util::issuer_api::{
-    CredentialSpec, Icrc21ConsentInfo,Icrc21VcConsentMessageRequest,  Icrc21ConsentPreferences, Icrc21Error, Icrc21ErrorInfo,
+    Icrc21ConsentInfo,Icrc21VcConsentMessageRequest,  Icrc21ConsentPreferences, Icrc21Error, Icrc21ErrorInfo,
 };
-use SupportedLanguage::{English, German};
+use SupportedLanguage::English;
 
-/// Consent messages for the VerifiedAdult VC to be shown and approved to the user during the VC sharing flow 
-const ADULT_VC_DESCRIPTION_EN: &str = r###"# Verified Adult
+/// Consent messages for the CivicPass VC to be shown and approved to the user during the VC sharing flow 
+/// Currently we only support English language
+const VC_DESCRIPTION_EN: &str = r###"# Verifiable Credential
 
-Credential that states that the holder's age is at least 18 years."###;
-const ADULT_VC_DESCRIPTION_DE: &str = r###"# Erwachsene Person
-
-Ausweis, der bestätigt, dass der Besitzer oder die Besitzerin mindestens 18 Jahre alt ist."###;
+Credential that states that the holder possesses a Verifiable Credential."###;
 
 lazy_static! {
     static ref CONSENT_MESSAGE_TEMPLATES: HashMap<(CredentialTemplateType, SupportedLanguage), &'static str> =
         HashMap::from([
             (
-                (CredentialTemplateType::VerifiedAdult, English),
-                ADULT_VC_DESCRIPTION_EN
-            ),
-            (
-                (CredentialTemplateType::VerifiedAdult, German),
-                ADULT_VC_DESCRIPTION_DE
+                (CredentialTemplateType::Credential, English),
+                VC_DESCRIPTION_EN
             )
         ]);
 }
 
 /// Supported consent message types
 #[derive(Clone, Eq, PartialEq, Hash)]
 pub enum CredentialTemplateType {
-    VerifiedAdult,
+    Credential,
 }
 
 /// Supported languages for consent messages
 #[derive(Clone, Eq, PartialEq, Hash)]
 pub enum SupportedLanguage {
     English,
-    German,
-}
-
-impl From<&SupportedCredentialType> for CredentialTemplateType {
-    fn from(value: &SupportedCredentialType) -> Self {
-        match value {
-            SupportedCredentialType::VerifiedAdult => CredentialTemplateType::VerifiedAdult,
-        }
-    }
 }
 
 impl From<Icrc21ConsentPreferences> for SupportedLanguage {
     fn from(value: Icrc21ConsentPreferences) -> Self {
         match &value.language.to_lowercase()[..2] {
-            "de" => German,
             _ => English, // english is also the fallback
         }
     }
@@ -66,7 +49,6 @@ impl Display for SupportedLanguage {
     fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
         match self {
             English => write!(f, "en"),
-            German => write!(f, "de"),
         }
     }
 }
@@ -79,38 +61,27 @@ async fn vc_consent_message(
     req: Icrc21VcConsentMessageRequest,
 ) -> Result<Icrc21ConsentInfo, Icrc21Error> {
     get_vc_consent_message(
-        &req.credential_spec,
         &SupportedLanguage::from(req.preferences),
     )
 }
 
 /// Retrieve the consent message for the given credential type and language.
 fn get_vc_consent_message(
-    credential_spec: &CredentialSpec,
     language: &SupportedLanguage,
 ) -> Result<Icrc21ConsentInfo, Icrc21Error> {
-    render_consent_message(credential_spec, language).map(|message| Icrc21ConsentInfo {
+    render_consent_message(language).map(|message| Icrc21ConsentInfo {
         consent_message: message,
         language: format!("{}", language),
     })
 }
 
 /// Show the consent message with any arguments 
 fn render_consent_message(
-    credential_spec: &CredentialSpec,
     language: &SupportedLanguage,
 ) -> Result<String, Icrc21Error> {
-    let credential_type = match verify_credential_spec(credential_spec) {
-        Ok(credential_type) => credential_type,
-        Err(err) => {
-            return Err(Icrc21Error::UnsupportedCanisterCall(Icrc21ErrorInfo {
-                description: err,
-            }));
-        }
-    };
     let template = CONSENT_MESSAGE_TEMPLATES
         .get(&(
-            CredentialTemplateType::from(&credential_type),
+            CredentialTemplateType::Credential,
             language.clone(),
         ))
         .ok_or(Icrc21Error::ConsentMessageUnavailable(Icrc21ErrorInfo {