(feat) Implement AnoncredsLedgerRead for cheqd #1306

.github/workflows/main.yml

@@ -342,6 +342,22 @@ jobs:
         with:
           name: "docker-services-${{ github.job }}"
 
+  test-integration-aries-vcx-ledger:
+    needs: workflow-setup
+    if: ${{ needs.workflow-setup.outputs.SKIP_CI != 'true' }}
+    runs-on: ubuntu-20.04
+    steps:
+      - name: "Git checkout"
+        uses: actions/checkout@v3
+      - name: "Setup rust testing environment"
+        uses: ./.github/actions/setup-testing-rust
+        with:
+          rust-toolchain-version: ${{ env.RUST_TOOLCHAIN_VERSION }}
+      - name: "Install just"
+        run: sudo snap install --edge --classic just
+      - name: "Run aries-vcx-ledger integration tests"
+        run: just test-integration-aries-vcx-ledger
+
   test-integration-did-crate:
     needs: workflow-setup
     if: ${{ needs.workflow-setup.outputs.SKIP_CI != 'true' }}

aries/aries_vcx/src/common/proofs/prover/prover_internal.rs

@@ -12,6 +12,7 @@ use aries_vcx_anoncreds::anoncreds::base_anoncreds::{
     BaseAnonCreds, CredentialDefinitionsMap, RevocationStatesMap, SchemasMap,
 };
 use aries_vcx_ledger::ledger::base_ledger::AnoncredsLedgerRead;
+use chrono::Utc;
 
 use crate::errors::error::prelude::*;
 
@@ -160,26 +161,25 @@ pub async fn build_rev_states_json(
             if !rtn.contains_key(rev_reg_id) {
                 // Does this make sense in case cred_info's for same rev_reg_ids have different
                 // revocation intervals
-                let (from, to) = if let Some(ref interval) = cred_info.revocation_interval {
+                let (_from, to) = if let Some(ref interval) = cred_info.revocation_interval {
                     (interval.from, interval.to)
                 } else {
                     (None, None)
                 };
 
-                let rev_reg_def_json = ledger_read
-                    .get_rev_reg_def_json(&rev_reg_id.to_owned().try_into()?)
-                    .await?;
+                let parsed_id = &rev_reg_id.to_owned().try_into()?;
+                let (rev_reg_def_json, meta) = ledger_read.get_rev_reg_def_json(parsed_id).await?;
 
-                let (rev_reg_delta_json, timestamp) = ledger_read
-                    .get_rev_reg_delta_json(&rev_reg_id.to_owned().try_into()?, from, to)
+                let on_or_before = to.unwrap_or(Utc::now().timestamp() as u64);
+                let (rev_status_list, timestamp) = ledger_read
+                    .get_rev_status_list(parsed_id, on_or_before, Some(&meta))
                     .await?;
 
                 let rev_state_json = anoncreds
                     .create_revocation_state(
                         Path::new(tails_dir),
                         rev_reg_def_json,
-                        rev_reg_delta_json,
-                        timestamp,
+                        rev_status_list,
                         *cred_rev_id,
                     )
                     .await?;

aries/aries_vcx/src/common/proofs/verifier/verifier_internal.rs

@@ -167,7 +167,7 @@ pub async fn build_rev_reg_defs_json(
             ))?;
 
         if rev_reg_defs_json.get(rev_reg_id).is_none() {
-            let json = ledger
+            let (json, _meta) = ledger
                 .get_rev_reg_def_json(&rev_reg_id.to_string().try_into()?)
                 .await?;
             let rev_reg_def_json = serde_json::to_value(&json).or(Err(AriesVcxError::from_msg(

aries/aries_vcx/src/errors/mapping_ledger.rs

@@ -8,7 +8,7 @@ impl From<VcxLedgerError> for AriesVcxError {
             VcxLedgerError::LedgerItemNotFound => {
                 Self::from_msg(AriesVcxErrorKind::LedgerItemNotFound, value)
             }
-            VcxLedgerError::InvalidLedgerResponse => {
+            VcxLedgerError::InvalidLedgerResponse(_) => {
                 Self::from_msg(AriesVcxErrorKind::InvalidLedgerResponse, value)
             }
             VcxLedgerError::DuplicationSchema => {
@@ -33,7 +33,9 @@ impl From<VcxLedgerError> for AriesVcxError {
                 Self::from_msg(AriesVcxErrorKind::PoolLedgerConnect, value)
             }
             VcxLedgerError::IOError(_) => Self::from_msg(AriesVcxErrorKind::IOError, value),
-            VcxLedgerError::InvalidInput(_) | VcxLedgerError::IndyVdrValidation(_) => {
+            VcxLedgerError::InvalidInput(_)
+            | VcxLedgerError::IndyVdrValidation(_)
+            | VcxLedgerError::UnsupportedLedgerIdentifier(_) => {
                 Self::from_msg(AriesVcxErrorKind::InvalidInput, value)
             }
             VcxLedgerError::UnknownError(_) => {

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

@@ -561,7 +561,7 @@ async fn _store_credential(
 
     let rev_reg_id = _parse_rev_reg_id_from_credential(&credential_json)?;
     let rev_reg_def_json = if let Some(rev_reg_id) = rev_reg_id {
-        let json = ledger.get_rev_reg_def_json(&rev_reg_id.try_into()?).await?;
+        let (json, _meta) = ledger.get_rev_reg_def_json(&rev_reg_id.try_into()?).await?;
         Some(json)
     } else {
         None

aries/aries_vcx_anoncreds/src/anoncreds/anoncreds/mod.rs

@@ -33,39 +33,41 @@ use anoncreds::{
         RevocationRegistryDefinition as AnoncredsRevocationRegistryDefinition,
     },
 };
-use anoncreds_types::data_types::{
-    identifiers::{
-        cred_def_id::CredentialDefinitionId, rev_reg_def_id::RevocationRegistryDefinitionId,
-        schema_id::SchemaId,
-    },
-    ledger::{
-        cred_def::{CredentialDefinition, SignatureType},
-        rev_reg::RevocationRegistry,
-        rev_reg_def::RevocationRegistryDefinition,
-        rev_reg_delta::{RevocationRegistryDelta, RevocationRegistryDeltaValue},
-        rev_status_list::RevocationStatusList,
-        schema::{AttributeNames, Schema},
-    },
-    messages::{
-        cred_definition_config::CredentialDefinitionConfig,
-        cred_offer::CredentialOffer,
-        cred_request::{CredentialRequest, CredentialRequestMetadata},
-        cred_selection::{
-            RetrievedCredentialForReferent, RetrievedCredentialInfo, RetrievedCredentials,
+use anoncreds_types::{
+    data_types::{
+        identifiers::{
+            cred_def_id::CredentialDefinitionId, rev_reg_def_id::RevocationRegistryDefinitionId,
+            schema_id::SchemaId,
+        },
+        ledger::{
+            cred_def::{CredentialDefinition, SignatureType},
+            rev_reg::RevocationRegistry,
+            rev_reg_def::RevocationRegistryDefinition,
+            rev_reg_delta::{RevocationRegistryDelta, RevocationRegistryDeltaValue},
+            rev_status_list::RevocationStatusList,
+            schema::{AttributeNames, Schema},
+        },
+        messages::{
+            cred_definition_config::CredentialDefinitionConfig,
+            cred_offer::CredentialOffer,
+            cred_request::{CredentialRequest, CredentialRequestMetadata},
+            cred_selection::{
+                RetrievedCredentialForReferent, RetrievedCredentialInfo, RetrievedCredentials,
+            },
+            credential::{Credential, CredentialValues},
+            nonce::Nonce,
+            pres_request::PresentationRequest,
+            presentation::{Presentation, RequestedCredentials},
+            revocation_state::CredentialRevocationState,
         },
-        credential::{Credential, CredentialValues},
-        nonce::Nonce,
-        pres_request::PresentationRequest,
-        presentation::{Presentation, RequestedCredentials},
-        revocation_state::CredentialRevocationState,
     },
+    utils::conversions::from_revocation_registry_delta_to_revocation_status_list,
 };
 use aries_vcx_wallet::wallet::{
     base_wallet::{record::Record, record_category::RecordCategory, BaseWallet},
     record_tags::{RecordTag, RecordTags},
 };
 use async_trait::async_trait;
-use bitvec::bitvec;
 use did_parser_nom::Did;
 use log::warn;
 use serde::{de::DeserializeOwned, Deserialize, Serialize};
@@ -82,36 +84,6 @@ use crate::{
     errors::error::{VcxAnoncredsError, VcxAnoncredsResult},
 };
 
-fn from_revocation_registry_delta_to_revocation_status_list(
-    delta: &RevocationRegistryDeltaValue,
-    rev_reg_def: &AnoncredsRevocationRegistryDefinition,
-    rev_reg_def_id: &RevocationRegistryDefinitionId,
-    timestamp: Option<u64>,
-    issuance_by_default: bool,
-) -> VcxAnoncredsResult<RevocationStatusList> {
-    let default_state = if issuance_by_default { 0 } else { 1 };
-    let mut revocation_list = bitvec![default_state; rev_reg_def.value.max_cred_num as usize];
-
-    for issued in &delta.issued {
-        revocation_list.insert(*issued as usize, false);
-    }
-
-    for revoked in &delta.revoked {
-        revocation_list.insert(*revoked as usize, true);
-    }
-
-    let accum = delta.accum.into();
-
-    RevocationStatusList::new(
-        Some(&rev_reg_def_id.to_string()),
-        rev_reg_def.issuer_id.clone().convert(())?,
-        revocation_list,
-        Some(accum),
-        timestamp,
-    )
-    .map_err(Into::into)
-}
-
 fn from_revocation_status_list_to_revocation_registry_delta(
     rev_status_list: &RevocationStatusList,
     prev_accum: Option<Accumulator>,
@@ -288,17 +260,35 @@ impl BaseAnonCreds for Anoncreds {
         let cred_defs: HashMap<AnoncredsCredentialDefinitionId, AnoncredsCredentialDefinition> =
             credential_defs_json.convert(())?;
 
+        // tack on issuerId for ease of processing status lists
+        let rev_regs_map_with_issuer_ids: Option<HashMap<_, _>> =
+            match (rev_regs_json, &rev_reg_defs_json) {
+                (Some(regs), Some(defs)) => Some(
+                    regs.into_iter()
+                        .filter_map(|(k, v)| {
+                            let def = defs.get(&k)?;
+                            Some((k, (v, def.issuer_id.clone())))
+                        })
+                        .collect(),
+                ),
+                _ => None,
+            };
+
         let rev_reg_defs: Option<
             HashMap<AnoncredsRevocationRegistryDefinitionId, AnoncredsRevocationRegistryDefinition>,
         > = rev_reg_defs_json.map(|v| v.convert(())).transpose()?;
 
+        let rev_status_lists = rev_regs_map_with_issuer_ids
+            .map(|r| r.convert(()))
+            .transpose()?;
+
         Ok(anoncreds::verifier::verify_presentation(
             &presentation,
             &pres_req,
             &schemas,
             &cred_defs,
             rev_reg_defs.as_ref(),
-            rev_regs_json.map(|r| r.convert(())).transpose()?,
+            rev_status_lists,
             None, // no idea what this is
         )?)
     }
@@ -947,18 +937,9 @@ impl BaseAnonCreds for Anoncreds {
         &self,
         tails_dir: &Path,
         rev_reg_def_json: RevocationRegistryDefinition,
-        rev_reg_delta_json: RevocationRegistryDelta,
-        timestamp: u64,
+        rev_status_list: RevocationStatusList,
         cred_rev_id: u32,
     ) -> VcxAnoncredsResult<CredentialRevocationState> {
-        let cred_def_id = rev_reg_def_json.cred_def_id.to_string();
-        let max_cred_num = rev_reg_def_json.value.max_cred_num;
-        let rev_reg_def_id = rev_reg_def_json.id.to_string();
-        let (_cred_def_method, issuer_did, _signature_type, _schema_num, _tag) =
-            cred_def_parts(&cred_def_id).ok_or(VcxAnoncredsError::InvalidSchema(format!(
-                "Could not process cred_def_id {cred_def_id} as parts."
-            )))?;
-
         let revoc_reg_def: AnoncredsRevocationRegistryDefinition = rev_reg_def_json.convert(())?;
         let tails_file_hash = revoc_reg_def.value.tails_hash.as_str();
 
@@ -970,25 +951,6 @@ impl BaseAnonCreds for Anoncreds {
             VcxAnoncredsError::InvalidOption("tails file is not an unicode string".into())
         })?;
 
-        let RevocationRegistryDeltaValue { accum, revoked, .. } = rev_reg_delta_json.value;
-
-        let issuer_id = IssuerId::new(issuer_did.did()).unwrap();
-        let mut revocation_list = bitvec!(0; max_cred_num as usize);
-        revoked.into_iter().for_each(|id| {
-            revocation_list
-                .get_mut(id as usize)
-                .map(|mut b| *b = true)
-                .unwrap_or_default()
-        });
-        let registry = CryptoRevocationRegistry { accum };
-
-        let rev_status_list = RevocationStatusList::new(
-            Some(&rev_reg_def_id),
-            issuer_id.convert(())?,
-            revocation_list,
-            Some(registry),
-            Some(timestamp),
-        )?;
         let rev_state = anoncreds::prover::create_or_update_revocation_state(
             tails_path,
             &revoc_reg_def,
@@ -1164,10 +1126,10 @@ impl BaseAnonCreds for Anoncreds {
         let current_time = OffsetDateTime::now_utc().unix_timestamp() as u64;
         let rev_status_list = from_revocation_registry_delta_to_revocation_status_list(
             &last_rev_reg_delta.value,
-            &rev_reg_def.clone().convert(())?,
-            rev_reg_id,
-            Some(current_time),
-            true,
+            current_time,
+            &rev_reg_def.id,
+            rev_reg_def.value.max_cred_num as usize,
+            rev_reg_def.issuer_id.clone(),
         )?;
 
         let cred_def = self