repo stringlengths 6 65 | file_url stringlengths 81 311 | file_path stringlengths 6 227 | content stringlengths 0 32.8k | language stringclasses 1 value | license stringclasses 7 values | commit_sha stringlengths 40 40 | retrieved_at stringdate 2026-01-04 15:31:58 2026-01-04 20:25:31 | truncated bool 2 classes |
|---|---|---|---|---|---|---|---|---|
openwallet-foundation/vcx | https://github.com/openwallet-foundation/vcx/blob/2d3034ed73ba8d49e0f72251b4c7cfb859a1efe7/aries/messages/src/msg_fields/protocols/out_of_band/mod.rs | aries/messages/src/msg_fields/protocols/out_of_band/mod.rs | //! Module containing the `out of band` protocol messages, as defined in the [RFC](<https://github.com/decentralized-identity/aries-rfcs/blob/main/features/0434-outofband/README.md>).
pub mod invitation;
pub mod reuse;
pub mod reuse_accepted;
use derive_more::From;
use serde::{de::Error, Deserialize, Deserializer, Serialize, Serializer};
use self::{
invitation::{Invitation, InvitationContent, InvitationDecorators},
reuse::{HandshakeReuse, HandshakeReuseContent, HandshakeReuseDecorators},
reuse_accepted::{
HandshakeReuseAccepted, HandshakeReuseAcceptedContent, HandshakeReuseAcceptedDecorators,
},
};
use crate::{
misc::utils::{into_msg_with_type, transit_to_aries_msg},
msg_fields::traits::DelayedSerde,
msg_types::{
protocols::out_of_band::{
OutOfBandType as OutOfBandKind, OutOfBandTypeV1, OutOfBandTypeV1_1,
},
MsgWithType,
},
};
#[derive(Clone, Debug, From, PartialEq)]
pub enum OutOfBand {
Invitation(Invitation),
HandshakeReuse(HandshakeReuse),
HandshakeReuseAccepted(HandshakeReuseAccepted),
}
impl DelayedSerde for OutOfBand {
type MsgType<'a> = (OutOfBandKind, &'a str);
fn delayed_deserialize<'de, D>(
msg_type: Self::MsgType<'de>,
deserializer: D,
) -> Result<Self, D::Error>
where
D: Deserializer<'de>,
{
let (protocol, kind_str) = msg_type;
let kind = match protocol {
OutOfBandKind::V1(OutOfBandTypeV1::V1_1(kind)) => kind.kind_from_str(kind_str),
};
match kind.map_err(D::Error::custom)? {
OutOfBandTypeV1_1::Invitation => Invitation::deserialize(deserializer).map(From::from),
OutOfBandTypeV1_1::HandshakeReuse => {
HandshakeReuse::deserialize(deserializer).map(From::from)
}
OutOfBandTypeV1_1::HandshakeReuseAccepted => {
HandshakeReuseAccepted::deserialize(deserializer).map(From::from)
}
}
}
fn delayed_serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
where
S: Serializer,
{
match self {
Self::Invitation(v) => MsgWithType::from(v).serialize(serializer),
Self::HandshakeReuse(v) => MsgWithType::from(v).serialize(serializer),
Self::HandshakeReuseAccepted(v) => MsgWithType::from(v).serialize(serializer),
}
}
}
#[derive(Debug, Serialize, Deserialize, Clone, Copy, PartialEq)]
pub enum OobGoalCode {
#[serde(rename = "issue-vc")]
IssueVC,
#[serde(rename = "request-proof")]
RequestProof,
#[serde(rename = "create-account")]
CreateAccount,
#[serde(rename = "p2p-messaging")]
P2PMessaging,
}
transit_to_aries_msg!(InvitationContent: InvitationDecorators, OutOfBand);
transit_to_aries_msg!(HandshakeReuseContent: HandshakeReuseDecorators, OutOfBand);
transit_to_aries_msg!(
HandshakeReuseAcceptedContent: HandshakeReuseAcceptedDecorators,
OutOfBand
);
into_msg_with_type!(Invitation, OutOfBandTypeV1_1, Invitation);
into_msg_with_type!(HandshakeReuse, OutOfBandTypeV1_1, HandshakeReuse);
into_msg_with_type!(
HandshakeReuseAccepted,
OutOfBandTypeV1_1,
HandshakeReuseAccepted
);
| rust | Apache-2.0 | 2d3034ed73ba8d49e0f72251b4c7cfb859a1efe7 | 2026-01-04T20:24:59.602734Z | false |
openwallet-foundation/vcx | https://github.com/openwallet-foundation/vcx/blob/2d3034ed73ba8d49e0f72251b4c7cfb859a1efe7/aries/messages/src/msg_fields/protocols/out_of_band/reuse.rs | aries/messages/src/msg_fields/protocols/out_of_band/reuse.rs | use serde::{Deserialize, Serialize};
use shared::misc::serde_ignored::SerdeIgnored;
use typed_builder::TypedBuilder;
use crate::{
decorators::{thread::Thread, timing::Timing},
msg_parts::MsgParts,
};
pub type HandshakeReuse = MsgParts<HandshakeReuseContent, HandshakeReuseDecorators>;
#[derive(Clone, Debug, Deserialize, Serialize, Default, PartialEq, TypedBuilder)]
#[serde(transparent)]
pub struct HandshakeReuseContent {
#[builder(default, setter(skip))]
inner: SerdeIgnored,
}
#[derive(Clone, Debug, Deserialize, Serialize, PartialEq, TypedBuilder)]
pub struct HandshakeReuseDecorators {
#[serde(rename = "~thread")]
pub thread: Thread,
#[builder(default, setter(strip_option))]
#[serde(rename = "~timing")]
#[serde(skip_serializing_if = "Option::is_none")]
pub timing: Option<Timing>,
}
#[cfg(test)]
#[allow(clippy::field_reassign_with_default)]
mod tests {
use serde_json::json;
use super::*;
use crate::{
decorators::{thread::tests::make_extended_thread, timing::tests::make_extended_timing},
misc::test_utils,
msg_types::out_of_band::OutOfBandTypeV1_1,
};
#[test]
fn test_minimal_reuse() {
let content = HandshakeReuseContent::default();
let decorators = HandshakeReuseDecorators::builder()
.thread(make_extended_thread())
.build();
let expected = json!({
"~thread": decorators.thread
});
test_utils::test_msg(
content,
decorators,
OutOfBandTypeV1_1::HandshakeReuse,
expected,
);
}
#[test]
fn test_extended_reuse() {
let content = HandshakeReuseContent::default();
let decorators = HandshakeReuseDecorators::builder()
.thread(make_extended_thread())
.timing(make_extended_timing())
.build();
let expected = json!({
"~thread": decorators.thread,
"~timing": decorators.timing
});
test_utils::test_msg(
content,
decorators,
OutOfBandTypeV1_1::HandshakeReuse,
expected,
);
}
}
| rust | Apache-2.0 | 2d3034ed73ba8d49e0f72251b4c7cfb859a1efe7 | 2026-01-04T20:24:59.602734Z | false |
openwallet-foundation/vcx | https://github.com/openwallet-foundation/vcx/blob/2d3034ed73ba8d49e0f72251b4c7cfb859a1efe7/aries/aries_vcx_ledger/src/lib.rs | aries/aries_vcx_ledger/src/lib.rs | pub mod errors;
pub mod ledger;
| rust | Apache-2.0 | 2d3034ed73ba8d49e0f72251b4c7cfb859a1efe7 | 2026-01-04T20:24:59.602734Z | false |
openwallet-foundation/vcx | https://github.com/openwallet-foundation/vcx/blob/2d3034ed73ba8d49e0f72251b4c7cfb859a1efe7/aries/aries_vcx_ledger/src/errors/mapping_indyvdr.rs | aries/aries_vcx_ledger/src/errors/mapping_indyvdr.rs | use indy_vdr::{
common::error::{VdrError, VdrErrorKind},
utils::ValidationError,
};
use crate::errors::error::VcxLedgerError;
impl From<VdrError> for VcxLedgerError {
fn from(err: VdrError) -> Self {
match err.kind() {
VdrErrorKind::Config => Self::InvalidConfiguration(err),
VdrErrorKind::Connection => Self::PoolLedgerConnect(err),
VdrErrorKind::FileSystem => Self::IOError(err),
VdrErrorKind::Input => Self::InvalidInput(err.to_string()),
VdrErrorKind::Resource
| VdrErrorKind::Unavailable
| VdrErrorKind::Unexpected
| VdrErrorKind::Incompatible
| VdrErrorKind::PoolNoConsensus
| VdrErrorKind::Resolver
| VdrErrorKind::PoolTimeout => Self::UnknownError(err.to_string()),
VdrErrorKind::PoolRequestFailed(_) => Self::InvalidLedgerResponse(err.to_string()),
}
}
}
impl From<ValidationError> for VcxLedgerError {
fn from(err: ValidationError) -> Self {
VcxLedgerError::InvalidInput(err.to_string())
}
}
| rust | Apache-2.0 | 2d3034ed73ba8d49e0f72251b4c7cfb859a1efe7 | 2026-01-04T20:24:59.602734Z | false |
openwallet-foundation/vcx | https://github.com/openwallet-foundation/vcx/blob/2d3034ed73ba8d49e0f72251b4c7cfb859a1efe7/aries/aries_vcx_ledger/src/errors/mapping_indyvdr_proxy.rs | aries/aries_vcx_ledger/src/errors/mapping_indyvdr_proxy.rs | use indy_vdr_proxy_client::error::VdrProxyClientError;
use super::error::VcxLedgerError;
impl From<VdrProxyClientError> for VcxLedgerError {
fn from(err: VdrProxyClientError) -> Self {
Self::InvalidLedgerResponse(err.to_string())
}
}
| rust | Apache-2.0 | 2d3034ed73ba8d49e0f72251b4c7cfb859a1efe7 | 2026-01-04T20:24:59.602734Z | false |
openwallet-foundation/vcx | https://github.com/openwallet-foundation/vcx/blob/2d3034ed73ba8d49e0f72251b4c7cfb859a1efe7/aries/aries_vcx_ledger/src/errors/error.rs | aries/aries_vcx_ledger/src/errors/error.rs | use aries_vcx_wallet::errors::error::VcxWalletError;
use did_parser_nom::ParseError;
use indy_vdr::common::error::VdrError;
use thiserror::Error as ThisError;
pub type VcxLedgerResult<T> = Result<T, VcxLedgerError>;
#[derive(Debug, ThisError)]
pub enum VcxLedgerError {
#[error("Invalid configuration: {0}")]
InvalidConfiguration(#[source] VdrError),
#[error("Pool ledger connect: {0}")]
PoolLedgerConnect(#[source] VdrError),
#[error("IO error: {0}")]
IOError(#[source] VdrError),
#[error("Ledger item not found")]
LedgerItemNotFound,
#[error("Invalid ledger response {0}")]
InvalidLedgerResponse(String),
#[error("Duplicated schema")]
DuplicationSchema,
#[error("Invalid JSON: {0}")]
InvalidJson(#[from] serde_json::Error),
#[error("Wallet error: {0}")]
WalletError(#[from] VcxWalletError),
#[error("Invalid state: {0}")]
InvalidState(String),
#[error("Invalid option: {0}")]
InvalidOption(String),
#[error("Invalid input: {0}")]
InvalidInput(String),
#[error("Unsupported ledger identifier: {0}")]
UnsupportedLedgerIdentifier(String),
#[error("Unknown error: {0}")]
UnknownError(String),
#[error("Indy Vdr Validation error: {0}")]
IndyVdrValidation(#[source] indy_vdr::utils::ValidationError),
#[error("Parse error: {0}")]
ParseError(#[from] ParseError),
#[error("Unimplemented feature: {0}")]
UnimplementedFeature(String),
}
| rust | Apache-2.0 | 2d3034ed73ba8d49e0f72251b4c7cfb859a1efe7 | 2026-01-04T20:24:59.602734Z | false |
openwallet-foundation/vcx | https://github.com/openwallet-foundation/vcx/blob/2d3034ed73ba8d49e0f72251b4c7cfb859a1efe7/aries/aries_vcx_ledger/src/errors/mapping_others.rs | aries/aries_vcx_ledger/src/errors/mapping_others.rs | use std::sync::PoisonError;
use super::error::VcxLedgerError;
impl<T> From<PoisonError<T>> for VcxLedgerError {
fn from(err: PoisonError<T>) -> Self {
VcxLedgerError::InvalidState(err.to_string())
}
}
impl From<Box<dyn std::error::Error>> for VcxLedgerError {
fn from(err: Box<dyn std::error::Error>) -> Self {
VcxLedgerError::InvalidState(err.to_string())
}
}
| rust | Apache-2.0 | 2d3034ed73ba8d49e0f72251b4c7cfb859a1efe7 | 2026-01-04T20:24:59.602734Z | false |
openwallet-foundation/vcx | https://github.com/openwallet-foundation/vcx/blob/2d3034ed73ba8d49e0f72251b4c7cfb859a1efe7/aries/aries_vcx_ledger/src/errors/mod.rs | aries/aries_vcx_ledger/src/errors/mod.rs | pub mod error;
#[cfg(feature = "cheqd")]
mod mapping_cheqd;
mod mapping_indyvdr;
#[cfg(feature = "vdr_proxy_ledger")]
mod mapping_indyvdr_proxy;
mod mapping_ledger_response_parser;
mod mapping_others;
| rust | Apache-2.0 | 2d3034ed73ba8d49e0f72251b4c7cfb859a1efe7 | 2026-01-04T20:24:59.602734Z | false |
openwallet-foundation/vcx | https://github.com/openwallet-foundation/vcx/blob/2d3034ed73ba8d49e0f72251b4c7cfb859a1efe7/aries/aries_vcx_ledger/src/errors/mapping_ledger_response_parser.rs | aries/aries_vcx_ledger/src/errors/mapping_ledger_response_parser.rs | use indy_ledger_response_parser::error::LedgerResponseParserError;
use super::error::VcxLedgerError;
impl From<LedgerResponseParserError> for VcxLedgerError {
fn from(err: LedgerResponseParserError) -> Self {
match err {
LedgerResponseParserError::JsonError(err) => VcxLedgerError::InvalidJson(err),
LedgerResponseParserError::LedgerItemNotFound(_) => VcxLedgerError::LedgerItemNotFound,
LedgerResponseParserError::InvalidTransaction(_) => {
VcxLedgerError::InvalidLedgerResponse(err.to_string())
}
}
}
}
| rust | Apache-2.0 | 2d3034ed73ba8d49e0f72251b4c7cfb859a1efe7 | 2026-01-04T20:24:59.602734Z | false |
openwallet-foundation/vcx | https://github.com/openwallet-foundation/vcx/blob/2d3034ed73ba8d49e0f72251b4c7cfb859a1efe7/aries/aries_vcx_ledger/src/errors/mapping_cheqd.rs | aries/aries_vcx_ledger/src/errors/mapping_cheqd.rs | use did_cheqd::error::{parsing::ParsingErrorSource, DidCheqdError};
use super::error::VcxLedgerError;
impl From<DidCheqdError> for VcxLedgerError {
fn from(value: DidCheqdError) -> Self {
match value {
DidCheqdError::MethodNotSupported(_) => VcxLedgerError::InvalidInput(value.to_string()),
DidCheqdError::NetworkNotSupported(_) => {
VcxLedgerError::InvalidInput(value.to_string())
}
DidCheqdError::BadConfiguration(_) => VcxLedgerError::InvalidInput(value.to_string()),
DidCheqdError::TransportError(_) => {
VcxLedgerError::InvalidLedgerResponse(value.to_string())
}
DidCheqdError::NonSuccessResponse(_) => {
VcxLedgerError::InvalidLedgerResponse(value.to_string())
}
DidCheqdError::InvalidResponse(_) => {
VcxLedgerError::InvalidLedgerResponse(value.to_string())
}
DidCheqdError::InvalidDidDocument(_) => VcxLedgerError::InvalidInput(value.to_string()),
DidCheqdError::InvalidDidUrl(_) => VcxLedgerError::InvalidInput(value.to_string()),
DidCheqdError::ParsingError(ParsingErrorSource::DidDocumentParsingError(e)) => {
VcxLedgerError::ParseError(e)
}
DidCheqdError::Other(_) => VcxLedgerError::UnknownError(value.to_string()),
_ => VcxLedgerError::UnknownError(value.to_string()),
}
}
}
| rust | Apache-2.0 | 2d3034ed73ba8d49e0f72251b4c7cfb859a1efe7 | 2026-01-04T20:24:59.602734Z | false |
openwallet-foundation/vcx | https://github.com/openwallet-foundation/vcx/blob/2d3034ed73ba8d49e0f72251b4c7cfb859a1efe7/aries/aries_vcx_ledger/src/ledger/type_conversion.rs | aries/aries_vcx_ledger/src/ledger/type_conversion.rs | use anoncreds_types::data_types::{
identifiers::{
cred_def_id::CredentialDefinitionId as OurCredentialDefinitionId, issuer_id::IssuerId,
rev_reg_def_id::RevocationRegistryDefinitionId as OurRevocationRegistryDefinitionId,
schema_id::SchemaId as OurSchemaId,
},
ledger::{
cred_def::{
CredentialDefinition as OurCredentialDefinition,
CredentialDefinitionData as OurCredentialDefinitionData,
SignatureType as OurSignatureType,
},
rev_reg::RevocationRegistry as OurRevocationRegistry,
rev_reg_def::{
RevocationRegistryDefinition as OurRevocationRegistryDefinition,
RevocationRegistryDefinitionValue as OurRevocationRegistryDefinitionValue,
RevocationRegistryDefinitionValuePublicKeys as OurRevocationRegistryDefinitionValuePublicKeys,
},
rev_reg_delta::RevocationRegistryDelta as OurRevocationRegistryDelta,
schema::Schema as OurSchema,
},
};
use did_parser_nom::Did;
use indy_vdr::{
ledger::{
identifiers::{
CredentialDefinitionId as IndyVdrCredentialDefinitionId,
RevocationRegistryId as IndyVdrRevocationRegistryId, SchemaId as IndyVdrSchemaId,
},
requests::{
cred_def::{
CredentialDefinition as IndyVdrCredentialDefinition, CredentialDefinitionData,
SignatureType as IndyVdrSignatureType,
},
rev_reg::{
RevocationRegistry as IndyVdrRevocationRegistry,
RevocationRegistryDelta as IndyVdrRevocationRegistryDelta,
RevocationRegistryDeltaV1,
},
rev_reg_def::{
IssuanceType, RevocationRegistryDefinition as IndyVdrRevocationRegistryDefinition,
RevocationRegistryDefinitionV1,
RevocationRegistryDefinitionValue as IndyVdrRevocationRegistryDefinitionValue,
RevocationRegistryDefinitionValuePublicKeys as IndyVdrRevocationRegistryDefinitionValuePublicKeys,
},
schema::{AttributeNames as IndyVdrAttributeNames, Schema as IndyVdrSchema, SchemaV1},
},
},
utils::did::DidValue,
};
pub trait Convert {
type Args;
type Target;
type Error;
fn convert(self, args: Self::Args) -> Result<Self::Target, Self::Error>;
}
impl Convert for IndyVdrSchema {
type Args = ();
type Target = OurSchema;
type Error = Box<dyn std::error::Error>;
fn convert(self, _: Self::Args) -> Result<Self::Target, Self::Error> {
match self {
IndyVdrSchema::SchemaV1(schema) => {
let issuer_id = schema.id.parts().unwrap().1.to_string();
Ok(OurSchema {
id: OurSchemaId::new(schema.id.to_string())?,
name: schema.name,
version: schema.version,
attr_names: schema.attr_names.0.into(),
issuer_id: IssuerId::new(issuer_id)?,
seq_no: schema.seq_no,
})
}
}
}
}
impl Convert for OurSchema {
type Args = ();
type Target = IndyVdrSchema;
type Error = Box<dyn std::error::Error>;
fn convert(self, _: ()) -> Result<Self::Target, Self::Error> {
Ok(IndyVdrSchema::SchemaV1(SchemaV1 {
id: IndyVdrSchemaId::new(
&indy_vdr::utils::did::DidValue::new(&self.issuer_id.0, None),
&self.name,
&self.version,
),
name: self.name,
attr_names: IndyVdrAttributeNames(self.attr_names.into()),
version: self.version,
seq_no: self.seq_no,
}))
}
}
impl Convert for &OurSchemaId {
type Args = ();
type Target = IndyVdrSchemaId;
type Error = Box<dyn std::error::Error>;
fn convert(self, _: Self::Args) -> Result<Self::Target, Self::Error> {
let parts = self.0.split(':').collect::<Vec<_>>();
let (_method, did, name, version) = if parts.len() == 4 {
// NcYxiDXkpYi6ov5FcYDi1e:2:gvt:1.0
let did = parts[0].to_string();
let name = parts[2].to_string();
let version = parts[3].to_string();
(None, DidValue(did), name, version)
} else if parts.len() == 8 {
// schema:sov:did:sov:NcYxiDXkpYi6ov5FcYDi1e:2:gvt:1.0
let method = parts[1];
let did = parts[2..5].join(":");
let name = parts[6].to_string();
let version = parts[7].to_string();
(Some(method), DidValue(did), name, version)
} else {
return Err("Invalid schema id".into());
};
Ok(IndyVdrSchemaId::new(&did, &name, &version))
}
}
impl Convert for &Did {
type Args = ();
type Target = DidValue;
type Error = Box<dyn std::error::Error>;
fn convert(self, _: Self::Args) -> Result<Self::Target, Self::Error> {
Ok(DidValue::new(&self.to_string(), None))
}
}
impl Convert for IndyVdrCredentialDefinition {
type Args = ();
type Target = OurCredentialDefinition;
type Error = Box<dyn std::error::Error>;
fn convert(self, (): Self::Args) -> Result<Self::Target, Self::Error> {
match self {
IndyVdrCredentialDefinition::CredentialDefinitionV1(cred_def) => {
let id = &cred_def.id;
let Some((_method, issuer_id, _sig_type, _schema_id, _tag)) = id.parts() else {
return Err(format!("cred def ID is malformed. cannot convert. {id}").into());
};
Ok(OurCredentialDefinition {
id: OurCredentialDefinitionId::new(id.to_string())?,
schema_id: OurSchemaId::new(cred_def.schema_id.to_string())?,
signature_type: OurSignatureType::CL,
tag: cred_def.tag,
value: OurCredentialDefinitionData {
primary: serde_json::from_value(cred_def.value.primary)?,
revocation: cred_def
.value
.revocation
.map(serde_json::from_value)
.transpose()?,
},
issuer_id: IssuerId::new(issuer_id.to_string())?,
})
}
}
}
}
impl Convert for OurCredentialDefinition {
type Args = ();
type Target = IndyVdrCredentialDefinition;
type Error = Box<dyn std::error::Error>;
fn convert(self, (): Self::Args) -> Result<Self::Target, Self::Error> {
Ok(IndyVdrCredentialDefinition::CredentialDefinitionV1(
indy_vdr::ledger::requests::cred_def::CredentialDefinitionV1 {
id: IndyVdrCredentialDefinitionId::from(self.id.to_string()),
schema_id: IndyVdrSchemaId::from(self.schema_id.to_string()),
signature_type: match self.signature_type {
OurSignatureType::CL => IndyVdrSignatureType::CL,
},
tag: self.tag,
value: CredentialDefinitionData {
primary: serde_json::to_value(self.value.primary)?,
revocation: self
.value
.revocation
.map(serde_json::to_value)
.transpose()?,
},
},
))
}
}
impl Convert for OurRevocationRegistryDefinition {
type Args = ();
type Target = IndyVdrRevocationRegistryDefinition;
type Error = Box<dyn std::error::Error>;
fn convert(self, (): Self::Args) -> Result<Self::Target, Self::Error> {
Ok(
IndyVdrRevocationRegistryDefinition::RevocationRegistryDefinitionV1(
RevocationRegistryDefinitionV1 {
id: IndyVdrRevocationRegistryId::from(self.id.to_string()),
revoc_def_type: indy_vdr::ledger::requests::rev_reg_def::RegistryType::CL_ACCUM,
tag: self.tag,
cred_def_id: IndyVdrCredentialDefinitionId::from(self.cred_def_id.to_string()),
value: IndyVdrRevocationRegistryDefinitionValue {
max_cred_num: self.value.max_cred_num,
public_keys: IndyVdrRevocationRegistryDefinitionValuePublicKeys {
accum_key: serde_json::to_value(self.value.public_keys.accum_key)?,
},
tails_hash: self.value.tails_hash,
tails_location: self.value.tails_location,
issuance_type: IssuanceType::ISSUANCE_BY_DEFAULT,
},
},
),
)
}
}
impl Convert for IndyVdrRevocationRegistryDefinition {
type Args = ();
type Target = OurRevocationRegistryDefinition;
type Error = Box<dyn std::error::Error>;
fn convert(self, (): Self::Args) -> Result<Self::Target, Self::Error> {
match self {
IndyVdrRevocationRegistryDefinition::RevocationRegistryDefinitionV1(rev_reg_def) => {
let Some((issuer_id, _cred_def, _type, _tag)) = rev_reg_def.id.parts() else {
return Err(format!("rev reg id is not valid: {}", rev_reg_def.id).into());
};
Ok(OurRevocationRegistryDefinition {
id: OurRevocationRegistryDefinitionId::new(rev_reg_def.id.to_string())?,
issuer_id: IssuerId::new(issuer_id.to_string())?,
revoc_def_type:
anoncreds_types::data_types::ledger::rev_reg_def::RegistryType::CL_ACCUM,
tag: rev_reg_def.tag,
cred_def_id: OurCredentialDefinitionId::new(
rev_reg_def.cred_def_id.to_string(),
)?,
value: OurRevocationRegistryDefinitionValue {
max_cred_num: rev_reg_def.value.max_cred_num,
public_keys: OurRevocationRegistryDefinitionValuePublicKeys {
accum_key: serde_json::from_value(
rev_reg_def.value.public_keys.accum_key,
)?,
},
tails_hash: rev_reg_def.value.tails_hash,
tails_location: rev_reg_def.value.tails_location,
},
})
}
}
}
}
impl Convert for IndyVdrRevocationRegistry {
type Args = ();
type Target = OurRevocationRegistry;
type Error = Box<dyn std::error::Error>;
fn convert(self, (): Self::Args) -> Result<Self::Target, Self::Error> {
match self {
IndyVdrRevocationRegistry::RevocationRegistryV1(rev_reg) => Ok(OurRevocationRegistry {
value: serde_json::from_value(rev_reg.value)?,
}),
}
}
}
impl Convert for IndyVdrRevocationRegistryDelta {
type Args = ();
type Target = OurRevocationRegistryDelta;
type Error = Box<dyn std::error::Error>;
fn convert(self, (): Self::Args) -> Result<Self::Target, Self::Error> {
match self {
IndyVdrRevocationRegistryDelta::RevocationRegistryDeltaV1(rev_reg) => {
Ok(OurRevocationRegistryDelta {
value: serde_json::from_value(rev_reg.value)?,
})
}
}
}
}
impl Convert for OurRevocationRegistryDelta {
type Args = ();
type Target = IndyVdrRevocationRegistryDelta;
type Error = Box<dyn std::error::Error>;
fn convert(self, (): Self::Args) -> Result<Self::Target, Self::Error> {
Ok(IndyVdrRevocationRegistryDelta::RevocationRegistryDeltaV1(
RevocationRegistryDeltaV1 {
value: serde_json::from_value(serde_json::to_value(self.value)?)?,
},
))
}
}
| rust | Apache-2.0 | 2d3034ed73ba8d49e0f72251b4c7cfb859a1efe7 | 2026-01-04T20:24:59.602734Z | false |
openwallet-foundation/vcx | https://github.com/openwallet-foundation/vcx/blob/2d3034ed73ba8d49e0f72251b4c7cfb859a1efe7/aries/aries_vcx_ledger/src/ledger/multi_ledger.rs | aries/aries_vcx_ledger/src/ledger/multi_ledger.rs | use std::fmt::Debug;
use anoncreds_types::data_types::{
identifiers::{
cred_def_id::CredentialDefinitionId, rev_reg_def_id::RevocationRegistryDefinitionId,
schema_id::SchemaId,
},
ledger::{
cred_def::CredentialDefinition, rev_reg::RevocationRegistry,
rev_reg_def::RevocationRegistryDefinition, rev_reg_delta::RevocationRegistryDelta,
rev_status_list::RevocationStatusList, schema::Schema,
},
};
use async_trait::async_trait;
use did_parser_nom::Did;
use serde::{Deserialize, Serialize};
use serde_json::Value;
use super::base_ledger::{AnoncredsLedgerRead, AnoncredsLedgerSupport};
use crate::errors::error::{VcxLedgerError, VcxLedgerResult};
// FUTURE - this multi-ledger anoncreds reader finds the first impl that supports the identifier
// and attempts to use it. This behaviour may need some enhancements in the future when
// considering coordination of unqualified object resolution, when multiple capable anoncreds
// readers are available (e.g. sovrin testnet & sovrin mainnet).
// Enhancements may include:
// * priority system - try A resolver before B if A & B both support the identifier
// * fallback/chain system - try A resolver, if it fails, try B resolver
// Alternatively these enhancements can be skipped if qualified DIDs/objects are used instead,
// e.g. did:indy:a:123, did:indy:b:123
/// Struct to aggregate multiple [AnoncredsLedgerRead] implementations into a single
/// [AnoncredsLedgerRead]. The child [AnoncredsLedgerRead] implementations are
/// utilized depending on whether or not they support resolution of the given object ID
/// (e.g. based on the DID Method).
#[derive(Default, Debug)]
pub struct MultiLedgerAnoncredsRead {
readers: Vec<Box<dyn AnoncredsLedgerReadAdaptorTrait>>,
}
#[async_trait]
impl AnoncredsLedgerRead for MultiLedgerAnoncredsRead {
type RevocationRegistryDefinitionAdditionalMetadata = Value;
async fn get_schema(
&self,
schema_id: &SchemaId,
submitter_did: Option<&Did>,
) -> VcxLedgerResult<Schema> {
let reader = self
.readers
.iter()
.find(|r| r.supports_schema(schema_id))
.ok_or(VcxLedgerError::UnsupportedLedgerIdentifier(
schema_id.to_string(),
))?;
reader.get_schema(schema_id, submitter_did).await
}
async fn get_cred_def(
&self,
cred_def_id: &CredentialDefinitionId,
submitter_did: Option<&Did>,
) -> VcxLedgerResult<CredentialDefinition> {
let reader = self
.readers
.iter()
.find(|r| r.supports_credential_definition(cred_def_id))
.ok_or(VcxLedgerError::UnsupportedLedgerIdentifier(
cred_def_id.to_string(),
))?;
reader.get_cred_def(cred_def_id, submitter_did).await
}
async fn get_rev_reg_def_json(
&self,
rev_reg_id: &RevocationRegistryDefinitionId,
) -> VcxLedgerResult<(
RevocationRegistryDefinition,
Self::RevocationRegistryDefinitionAdditionalMetadata,
)> {
let reader = self
.readers
.iter()
.find(|r| r.supports_revocation_registry(rev_reg_id))
.ok_or(VcxLedgerError::UnsupportedLedgerIdentifier(
rev_reg_id.to_string(),
))?;
reader.get_rev_reg_def_json(rev_reg_id).await
}
async fn get_rev_reg_delta_json(
&self,
rev_reg_id: &RevocationRegistryDefinitionId,
from: Option<u64>,
to: Option<u64>,
) -> VcxLedgerResult<(RevocationRegistryDelta, u64)> {
let reader = self
.readers
.iter()
.find(|r| r.supports_revocation_registry(rev_reg_id))
.ok_or(VcxLedgerError::UnsupportedLedgerIdentifier(
rev_reg_id.to_string(),
))?;
#[allow(deprecated)] // TODO - https://github.com/openwallet-foundation/vcx/issues/1309
reader.get_rev_reg_delta_json(rev_reg_id, from, to).await
}
async fn get_rev_status_list(
&self,
rev_reg_id: &RevocationRegistryDefinitionId,
timestamp: u64,
rev_reg_def_meta: Option<&Self::RevocationRegistryDefinitionAdditionalMetadata>,
) -> VcxLedgerResult<(RevocationStatusList, u64)> {
let reader = self
.readers
.iter()
.find(|r| r.supports_revocation_registry(rev_reg_id))
.ok_or(VcxLedgerError::UnsupportedLedgerIdentifier(
rev_reg_id.to_string(),
))?;
reader
.get_rev_status_list(rev_reg_id, timestamp, rev_reg_def_meta)
.await
}
async fn get_rev_reg(
&self,
rev_reg_id: &RevocationRegistryDefinitionId,
timestamp: u64,
) -> VcxLedgerResult<(RevocationRegistry, u64)> {
let reader = self
.readers
.iter()
.find(|r| r.supports_revocation_registry(rev_reg_id))
.ok_or(VcxLedgerError::UnsupportedLedgerIdentifier(
rev_reg_id.to_string(),
))?;
reader.get_rev_reg(rev_reg_id, timestamp).await
}
}
impl MultiLedgerAnoncredsRead {
pub fn new() -> Self {
Self::default()
}
pub fn register_reader<T>(mut self, reader: T) -> Self
where
T: AnoncredsLedgerRead + AnoncredsLedgerSupport + 'static,
for<'de> <T as AnoncredsLedgerRead>::RevocationRegistryDefinitionAdditionalMetadata:
Serialize + Deserialize<'de> + Send + Sync,
{
let adaptor = AnoncredsLedgerReadAdaptor { inner: reader };
self.readers.push(Box::new(adaptor));
self
}
}
impl AnoncredsLedgerSupport for MultiLedgerAnoncredsRead {
fn supports_schema(&self, id: &SchemaId) -> bool {
self.readers.iter().any(|r| r.supports_schema(id))
}
fn supports_credential_definition(&self, id: &CredentialDefinitionId) -> bool {
self.readers
.iter()
.any(|r| r.supports_credential_definition(id))
}
fn supports_revocation_registry(&self, id: &RevocationRegistryDefinitionId) -> bool {
self.readers
.iter()
.any(|r| r.supports_revocation_registry(id))
}
}
#[derive(Debug)]
pub struct AnoncredsLedgerReadAdaptor<T> {
inner: T,
}
pub trait AnoncredsLedgerReadAdaptorTrait:
AnoncredsLedgerRead<RevocationRegistryDefinitionAdditionalMetadata = Value> + AnoncredsLedgerSupport
{
}
impl<T> AnoncredsLedgerSupport for AnoncredsLedgerReadAdaptor<T>
where
T: AnoncredsLedgerSupport,
{
fn supports_schema(&self, id: &SchemaId) -> bool {
self.inner.supports_schema(id)
}
fn supports_credential_definition(&self, id: &CredentialDefinitionId) -> bool {
self.inner.supports_credential_definition(id)
}
fn supports_revocation_registry(&self, id: &RevocationRegistryDefinitionId) -> bool {
self.inner.supports_revocation_registry(id)
}
}
#[async_trait]
impl<T> AnoncredsLedgerRead for AnoncredsLedgerReadAdaptor<T>
where
T: AnoncredsLedgerRead,
T::RevocationRegistryDefinitionAdditionalMetadata:
Serialize + for<'de> Deserialize<'de> + Send + Sync,
{
type RevocationRegistryDefinitionAdditionalMetadata = Value;
async fn get_schema(
&self,
schema_id: &SchemaId,
submitter_did: Option<&Did>,
) -> VcxLedgerResult<Schema> {
self.inner.get_schema(schema_id, submitter_did).await
}
async fn get_cred_def(
&self,
cred_def_id: &CredentialDefinitionId,
submitter_did: Option<&Did>,
) -> VcxLedgerResult<CredentialDefinition> {
self.inner.get_cred_def(cred_def_id, submitter_did).await
}
async fn get_rev_reg_def_json(
&self,
rev_reg_id: &RevocationRegistryDefinitionId,
) -> VcxLedgerResult<(
RevocationRegistryDefinition,
Self::RevocationRegistryDefinitionAdditionalMetadata,
)> {
let (reg, meta) = self.inner.get_rev_reg_def_json(rev_reg_id).await?;
Ok((reg, serde_json::to_value(meta)?))
}
async fn get_rev_reg_delta_json(
&self,
rev_reg_id: &RevocationRegistryDefinitionId,
from: Option<u64>,
to: Option<u64>,
) -> VcxLedgerResult<(RevocationRegistryDelta, u64)> {
#[allow(deprecated)] // TODO - https://github.com/openwallet-foundation/vcx/issues/1309
self.inner
.get_rev_reg_delta_json(rev_reg_id, from, to)
.await
}
async fn get_rev_status_list(
&self,
rev_reg_id: &RevocationRegistryDefinitionId,
timestamp: u64,
rev_reg_def_meta: Option<&Self::RevocationRegistryDefinitionAdditionalMetadata>,
) -> VcxLedgerResult<(RevocationStatusList, u64)> {
let meta = match rev_reg_def_meta {
Some(v) => Some(serde_json::from_value(v.to_owned())?),
None => None,
};
self.inner
.get_rev_status_list(rev_reg_id, timestamp, meta.as_ref())
.await
}
async fn get_rev_reg(
&self,
rev_reg_id: &RevocationRegistryDefinitionId,
timestamp: u64,
) -> VcxLedgerResult<(RevocationRegistry, u64)> {
self.inner.get_rev_reg(rev_reg_id, timestamp).await
}
}
impl<T> AnoncredsLedgerReadAdaptorTrait for AnoncredsLedgerReadAdaptor<T>
where
T: AnoncredsLedgerRead + AnoncredsLedgerSupport,
T::RevocationRegistryDefinitionAdditionalMetadata:
Serialize + for<'de> Deserialize<'de> + Send + Sync,
{
}
#[cfg(test)]
mod unit_tests {
use async_trait::async_trait;
use mockall::{mock, predicate::eq};
use serde_json::json;
use super::*;
mock! {
#[derive(Debug)]
pub Reader {}
#[async_trait]
impl AnoncredsLedgerRead for Reader {
type RevocationRegistryDefinitionAdditionalMetadata = Value;
// NOTE: these method signatures were generated as a result of the expanded #[async_trait] form.
// this was needed to escape some #[async_trait] compiling issues
fn get_schema<'life0,'life1,'life2,'async_trait>(&'life0 self,schema_id: &'life1 SchemaId,submitter_did:Option< &'life2 Did> ,) -> ::core::pin::Pin<Box<dyn ::core::future::Future<Output = VcxLedgerResult<Schema> > + ::core::marker::Send+'async_trait> >where 'life0:'async_trait,'life1:'async_trait,'life2:'async_trait,Self:'async_trait;
fn get_cred_def<'life0,'life1,'life2,'async_trait>(&'life0 self,cred_def_id: &'life1 CredentialDefinitionId,submitter_did:Option< &'life2 Did> ,) -> ::core::pin::Pin<Box<dyn ::core::future::Future<Output = VcxLedgerResult<CredentialDefinition> > + ::core::marker::Send+'async_trait> >where 'life0:'async_trait,'life1:'async_trait,'life2:'async_trait,Self:'async_trait;
async fn get_rev_reg_def_json(&self, rev_reg_id: &RevocationRegistryDefinitionId) -> VcxLedgerResult<(RevocationRegistryDefinition, Value)>;
async fn get_rev_reg_delta_json(&self, rev_reg_id: &RevocationRegistryDefinitionId, from: Option<u64>, to: Option<u64>) -> VcxLedgerResult<(RevocationRegistryDelta, u64)>;
#[allow(clippy::type_complexity)] // generated
fn get_rev_status_list<'life0,'life1,'life2,'async_trait>(&'life0 self,rev_reg_id: &'life1 RevocationRegistryDefinitionId,timestamp:u64,rev_reg_def_meta:Option< &'life2 Value>) -> ::core::pin::Pin<Box<dyn ::core::future::Future<Output = VcxLedgerResult<(RevocationStatusList,u64)> > + ::core::marker::Send+'async_trait> >where 'life0:'async_trait,'life1:'async_trait,'life2:'async_trait,Self:'async_trait;
async fn get_rev_reg(&self, rev_reg_id: &RevocationRegistryDefinitionId, timestamp: u64) -> VcxLedgerResult<(RevocationRegistry, u64)>;
}
impl AnoncredsLedgerSupport for Reader {
fn supports_schema(&self, id: &SchemaId) -> bool;
fn supports_credential_definition(&self, id: &CredentialDefinitionId) -> bool;
fn supports_revocation_registry(&self, id: &RevocationRegistryDefinitionId) -> bool;
}
}
#[test]
fn test_anoncreds_supports_schema_if_any_support() {
let mut reader1 = MockReader::new();
reader1.expect_supports_schema().return_const(false);
let mut reader2 = MockReader::new();
reader2.expect_supports_schema().return_const(false);
let mut reader3 = MockReader::new();
reader3.expect_supports_schema().return_const(true);
// no readers
let mut reader = MultiLedgerAnoncredsRead::new();
assert!(!reader.supports_schema(&SchemaId::new_unchecked("")));
// with reader 1
reader = reader.register_reader(reader1);
assert!(!reader.supports_schema(&SchemaId::new_unchecked("")));
// with reader 1,2
reader = reader.register_reader(reader2);
assert!(!reader.supports_schema(&SchemaId::new_unchecked("")));
// with reader 1,2,3
reader = reader.register_reader(reader3);
assert!(reader.supports_schema(&SchemaId::new_unchecked("")));
}
#[test]
fn test_anoncreds_supports_cred_def_if_any_support() {
let mut reader1 = MockReader::new();
reader1
.expect_supports_credential_definition()
.return_const(false);
let mut reader2 = MockReader::new();
reader2
.expect_supports_credential_definition()
.return_const(false);
let mut reader3 = MockReader::new();
reader3
.expect_supports_credential_definition()
.return_const(true);
// no readers
let mut reader = MultiLedgerAnoncredsRead::new();
assert!(!reader.supports_credential_definition(&CredentialDefinitionId::new_unchecked("")));
// with reader 1
reader = reader.register_reader(reader1);
assert!(!reader.supports_credential_definition(&CredentialDefinitionId::new_unchecked("")));
// with reader 1,2
reader = reader.register_reader(reader2);
assert!(!reader.supports_credential_definition(&CredentialDefinitionId::new_unchecked("")));
// with reader 1,2,3
reader = reader.register_reader(reader3);
assert!(reader.supports_credential_definition(&CredentialDefinitionId::new_unchecked("")));
}
#[test]
fn test_anoncreds_supports_rev_reg_if_any_support() {
let mut reader1 = MockReader::new();
reader1
.expect_supports_revocation_registry()
.return_const(false);
let mut reader2 = MockReader::new();
reader2
.expect_supports_revocation_registry()
.return_const(false);
let mut reader3 = MockReader::new();
reader3
.expect_supports_revocation_registry()
.return_const(true);
// no readers
let mut reader = MultiLedgerAnoncredsRead::new();
assert!(!reader
.supports_revocation_registry(&RevocationRegistryDefinitionId::new_unchecked("")));
// with reader 1
reader = reader.register_reader(reader1);
assert!(!reader
.supports_revocation_registry(&RevocationRegistryDefinitionId::new_unchecked("")));
// with reader 1,2
reader = reader.register_reader(reader2);
assert!(!reader
.supports_revocation_registry(&RevocationRegistryDefinitionId::new_unchecked("")));
// with reader 1,2,3
reader = reader.register_reader(reader3);
assert!(
reader.supports_revocation_registry(&RevocationRegistryDefinitionId::new_unchecked(""))
);
}
#[tokio::test]
async fn test_get_schema_proxy() {
let id = SchemaId::new_unchecked(uuid::Uuid::new_v4().to_string());
let schema: Schema = serde_json::from_value(json!({
"id": "2hoqvcwupRTUNkXn6ArYzs:2:test-licence:4.4.4",
"issuerId": "https://example.org/issuers/74acabe2-0edc-415e-ad3d-c259bac04c15",
"name": "Example schema",
"version": "0.0.1",
"attrNames": ["name", "age", "vmax"]
}))
.unwrap();
let mut reader1 = MockReader::new();
reader1.expect_supports_schema().return_const(false);
let mut reader2 = MockReader::new();
reader2.expect_supports_schema().return_const(true);
let return_schema = schema.clone();
let expected_id = id.clone();
reader2
.expect_get_schema()
.times(1)
.withf(move |id, _| id == &expected_id)
.return_once(move |_, _| {
let schema = return_schema.clone();
Box::pin(async { Ok(schema) })
});
let reader = MultiLedgerAnoncredsRead::new()
.register_reader(reader1)
.register_reader(reader2);
let actual_schema = reader.get_schema(&id, None).await.unwrap();
assert_eq!(actual_schema, schema);
}
#[tokio::test]
async fn test_get_cred_def_proxy() {
let id = CredentialDefinitionId::new_unchecked(uuid::Uuid::new_v4().to_string());
let cred_def: CredentialDefinition = serde_json::from_value(json!({
"issuerId":"2hoqvcwupRTUNkXn6ArYzs",
"id":"V4SGRU86Z58d6TV7PBUe6f:3:CL:47:tag1",
"schemaId":"47",
"type":"CL",
"tag":"tag1",
"value":{"primary":{"n":"84315068910733942941538809865498212264459549000792879639194636554256493686411316918356364554212859153177297904254803226691261360163017568975126644984686667408908554649062870983454913573717132685671583694031717814141080679830350673819424952039249083306114176943232365022146274429759329160659813641353420711789491657407711667921406386914492317126931232096716361835185621871614892278526459017279649489759883446875710292582916862323180484745724279188511139859961558899492420881308319897939707149225665665750089691347075452237689762438550797003970061912118059748053097698671091262939106899007559343210815224380894488995113","s":"59945496099091529683010866609186265795684084593915879677365915314463441987443154552461559065352420479185095999059693986296256981985940684025427266913415378231498151267007158809467729823827861060943249985214295565954619712884813475078876243461567805408186530126430117091175878433493470477405243290350006589531746383498912735958116529589160259765518623375993634632483497463706818065357079852866706817198531892216731574724567574484572625164896490617904130456390333434781688685711531389963108606060826034467848677030185954836450146848456029587966315982491265726825962242361193382187200762212532433623355158921675478443655","r":{"date":"4530952538742033870264476947349521164360569832293598526413037147348444667070532579011380195228953804587892910083371419619205239227176615305655903664544843027114068926732016634797988559479373173420379032359085866159812396874183493337593923986352373367443489125306598512961937690050408637316178808308468698130916843726350286470498112647012795872536655274223930769557053638433983185163528151238000191689201476902211980373037910868763273992732059619082351273391415938130689371576452787378432526477108387174464183508295202268819673712009207498503854885022563424081101176507778361451123464434452487512804710607807387159128","age":"15503562420190113779412573443648670692955804417106499721072073114914016752313409982751974380400397358007517489487316569306402072592113120841927939614225596950574350717260042735712458756920802142037678828871321635736672163943850608100354921834523463955560137056697629609048487954091228011758465160630168342803951659774432090950114225268433943738713511960512519720523823132697152235977167573478225681125743108316237901888395175219199986619980202460002105538052202194307901021813863765169429019328213794814861353730831662815923471654084390063142965516688500592978949402225958824367010905689069418109693434050714606537583","master_secret":"14941959991861844203640254789113219741444241402376608919648803136983822447657869566295932734574583636024573117873598134469823095273660720727015649700465955361130129864938450014649937111357170711555934174503723640116145690157792143484339964157425981213977310483344564302214614951542098664609872435210449645226834832312148045998264085006307562873923691290268448463268834055489643805348568651181211925383052438130996893167066397253030164424601706641019876113890399331369874738474583032456630131756536716380809815371596958967704560484978381009830921031570414600773593753852611696648360844881738828836829723309887344258937","degree":"67311842668657630299931187112088054454211766880915366228670112262543717421860411017794917555864962789983330613927578732076546462151555711446970436129702520726176833537897538147071443776547628756352432432835899834656529545556299956904072273738406120215054506535933414063527222201017224487746551625599741110865905908376807007226016794285559868443574843566769079505217003255193711592800832900528743423878219697996298053773029816576222817010079313631823474213756143038164999157352990720891769630050634864109412199796030812795554794690666251581638175258059399898533412136730015599390155694930639754604259112806273788686507","name":"40219920836667226846980595968749841377080664270433982561850197901597771608457272395564987365558822976616985553706043669221173208652485993987057610703687751081160705282278075965587059598006922553243119778614657332904443210949022832267152413602769950017196241603290054807405460837019722951966510572795690156337466164027728801433988397914462240536123226066351251559900540164628048512242681757179461134506191038056117474598282470153495944204106741140156797129717000379741035610651103388047392025454843123388667794650989667119908702980140953817053781064048661940525040691050449058181790166453523432033421772638164421440685"},"rctxt":"82211384518226913414705883468527183492640036595481131419387459490531641219140075943570487048949702495964452189878216535351106872901004288800618738558792099255633906919332859771231971995964089510050225371749467514963769062274472125808020747444043470829002911273221886787637565057381007986495929400181408859710441856354570835196999403016572481694010972193591132652075787983469256801030377358546763251500115728919042442285672299538383497028946509014399210152856456151424115321673276206158701693427269192935107281015760959764697283756967072538997471422184132520456634304294669685041869025373789168601981777301930702142717","z":"597630352445077967631363625241310742422278192985165396805410934637833378871905757950406233560527227666603560941363695352019306999881059381981398160064772044355803827657704204341958693819520622597159046224481967205282164000142449330594352761829061889177257816365267888924702641013893644925126158726833651215929952524830180400844722456288706452674387695005404773156271263201912761375013255052598817079064887267420056304601888709527771529363399401864219168554878211931445812982845627741042319366707757767391990264005995464401655063121998656818808854159318505715730088491626077711079755220554530286586303737320102790443"},"revocation":{"g":"1 163FAAD4EB9AA0DF02C19EAC9E91DAFF5C9EEC50B13D59613BB03AC57A864724 1 091121B3A92D2C48A12FB2B6904AFDA9708EAC9CBDF4E9BF988C9071BB4CFEC2 2 095E45DDF417D05FB10933FFC63D474548B7FFFF7888802F07FFFFFF7D07A8A8","g_dash":"1 165E30BED89E08D23FC61685E5F38A65A74342EDF75283BE2E3D7A84D036AC1F 1 07D4894035E05420317656B39B0104E2E6CF372024C8DA9B5E69C05D073DEE17 1 2408458D7F1B790AC27A05055FB7DB562BD51E2597BC3CA5713589716A128647 1 1965D421EA07B38C9C287348BC6AAC53B7FF6E44DE6AC3202F4E62B147019FB3 2 095E45DDF417D05FB10933FFC63D474548B7FFFF7888802F07FFFFFF7D07A8A8 1 0000000000000000000000000000000000000000000000000000000000000000","h":"1 1EC742963B128F781DEC49BF60E9D7D627BE75EE6DB6FC7EC0A4388EB6EDDD5E 1 0A98F72733982BF22B83E40FB03AA339C990424498DFF7D227B75F442F089E71 2 095E45DDF417D05FB10933FFC63D474548B7FFFF7888802F07FFFFFF7D07A8A8","h0":"1 1EBE1D3B82473D8435B13E1B22B9B8A3FFD8251F3FACF423CE3CF0A63AF81D6B 1 10890876E36CCB96308ED4C284CDC4B2B014AE67404207E73F287EC86ACFE809 2 095E45DDF417D05FB10933FFC63D474548B7FFFF7888802F07FFFFFF7D07A8A8","h1":"1 21F6A9DA5A812DB4840340A817788CC84EB3C079E07C9908E9637C0A00F2DD56 1 1B1A0005E895B479500E818FC2280B6D06C088788CCF44C07E94B55941EE85F6 2 095E45DDF417D05FB10933FFC63D474548B7FFFF7888802F07FFFFFF7D07A8A8","h2":"1 180ADD04BFF577BCC49D09F97A9C11347C7A0359A0347DE9F138393CAF5F1F93 1 1044FFDF4AC72BBD8B6CC38D918A7C64A441E53D4561A7F5799B68D48E355294 2 095E45DDF417D05FB10933FFC63D474548B7FFFF7888802F07FFFFFF7D07A8A8","htilde":"1 031D6DDE2A7B05F29EFB574973E6D54AE36B79EBDD0599CD5AD2DF93BDBD0661 1 23A358FEC4883CE1EF44EEC1640B4D4C27FF5C7D64E9798BBF2C5A0D414D1AB5 2 095E45DDF417D05FB10933FFC63D474548B7FFFF7888802F07FFFFFF7D07A8A8","h_cap":"1 1536F787B8F6676E31B769543085CC12E484D6B9A136A29E05723DE993E52C78 1 05EF3C2E5AC1F62132E1F62AC715588203902BCBA8D40203606E6834F9065BB5 1 09878859092CA40C7D5AB4D42F6AFC16987CC90C361F161F9383BCD70F0BD7F0 1 2472E732278D393032B33DEDD2F38F84C3D05E109819E97D462D55822FD14DAA 2 095E45DDF417D05FB10933FFC63D474548B7FFFF7888802F07FFFFFF7D07A8A8 1 0000000000000000000000000000000000000000000000000000000000000000","u":"1 11523B940E760339BBDA36AE6B2DDA570E9CCC2E9314744FCB6C767DF022C5CF 1 1DADE6A6EBFFB2D329A691DB51C3A862F5FBD7D6BD5E594216E613BE882DBC02 1 0E4DE16A4C7514B7F1E09D1253F79B1D3127FD45AB2E535717BA2912F048D587 1 14A1436619A0C1B02302D66D78CE66027A1AAF44FC6FA0BA605E045526A76B76 2 095E45DDF417D05FB10933FFC63D474548B7FFFF7888802F07FFFFFF7D07A8A8 1 0000000000000000000000000000000000000000000000000000000000000000","pk":"1 0CBF9F57DD1607305F2D6297E85CA9B1D71BCBDCE26E10329224C4EC3C0299D6 1 01EE49B4D07D933E518E9647105408758B1D7E977E66E976E4FE4A2E66F8E734 2 095E45DDF417D05FB10933FFC63D474548B7FFFF7888802F07FFFFFF7D07A8A8","y":"1 1D2618B8EA3B4E1C5C8D0382940E34DA19425E3CE69C2F6A55F10352ABDF7BD9 1 1F45619B4247A65FDFE577B6AE40474F53E94A83551622859795E71B44920FA0 1 21324A71042C04555C2C89881F297E6E4FB10BA3949B0C3C345B4E5EE4C48100 1 0FAF04961F119E50C72FF39E7E7198EBE46C2217A87A47C6A6A5BFAB6D39E1EE 2 095E45DDF417D05FB10933FFC63D474548B7FFFF7888802F07FFFFFF7D07A8A8 1 0000000000000000000000000000000000000000000000000000000000000000"}}
}))
.unwrap();
let mut reader1 = MockReader::new();
reader1
.expect_supports_credential_definition()
.return_const(false);
let mut reader2 = MockReader::new();
reader2
.expect_supports_credential_definition()
.return_const(true);
let return_cred_def = cred_def.try_clone().unwrap();
let expected_id = id.clone();
reader2
.expect_get_cred_def()
.times(1)
.withf(move |id, _| id == &expected_id)
.return_once(move |_, _| {
let cred_def = return_cred_def.try_clone().unwrap();
Box::pin(async { Ok(cred_def) })
});
let reader = MultiLedgerAnoncredsRead::new()
.register_reader(reader1)
.register_reader(reader2);
let actual_cred_def = reader.get_cred_def(&id, None).await.unwrap();
assert_eq!(
serde_json::to_value(actual_cred_def).unwrap(),
serde_json::to_value(cred_def).unwrap()
);
}
#[tokio::test]
async fn test_get_rev_reg_def_proxy() {
let id = RevocationRegistryDefinitionId::new_unchecked(uuid::Uuid::new_v4().to_string());
let rev_reg_def: RevocationRegistryDefinition = serde_json::from_value(json!({
"id": id,
"issuerId": "did:cheqd:testnet:8bbd2026-03f5-42c7-bf80-09f46fc4d67b",
"credDefId": "did:cheqd:testnet:8bbd2026-03f5-42c7-bf80-09f46fc4d67b/resources/8372c1bc-907d-44a9-86be-ac3672b26e2e",
"revocDefType": "CL_ACCUM",
"tag": "1.0",
"value": {
"maxCredNum": 5,
"publicKeys": {
"accumKey": {
"z": "1 10D3560CAE0591EEA7D7A63E1A362FC31448EF321E04FD75F248BBAF02DE9749 1 118C4B0C7F3D86D46C22D62BAE7E613B137A879B50EFDFC56451AB9012BA57A0 1 23D6952F9D058744D4930D1DE6D79548BDCA3EE8BAAF64B712668E52A1290547 1 14C4C4389D92A99C4DA7E6CC2BD0C82E2809D3CD202CD2F0AD6C33D75AA39049 1 174EACBC7981492A791A72D57C6CB9FE488A679C4A5674E4F3C247D73A827384 1 0172B8961122D4D825B282CA1CD1BBC3B8DC459994C9FE2827CDF74B3AB08D38 1 181159044E453DC59FF320E9E08C666176F6B9309E162E2DA4FC1DB3156F7B1F 1 2323CEBFB26C6D28CBAF5F87F155362C6FA14AFA0EBA7DE2B4154FE4082E30FD 1 2354CB1624B42A284B41E5B3B4489C2795DBA9B88A725005555FB698AFF97260 1 07EEEF48EF52E5B15FD4AC28F0DAEDE0A259A27500855992307518A0DBE29A83 1 00FE73BCDB27D1DAD37E4F0E424372CA9548F11B4EC977DCCCC53D99A5C66F36 1 07E9DC0DD2163A66EDA84CD6BF282C7E18CB821762B6047CA1AB9FBE94DC6546"
}
},
"tailsHash": "GW1bmjcMmtHnLwbWrabX4sWYVopJMEvQWgYMAEDmbJS3",
"tailsLocation": "GW1bmjcMmtHnLwbWrabX4sWYVopJMEvQWgYMAEDmbJS3"
}
}))
.unwrap();
let meta = json!({
"foo": "bar",
uuid::Uuid::new_v4().to_string(): [uuid::Uuid::new_v4().to_string()],
});
let mut reader1 = MockReader::new();
reader1
.expect_supports_revocation_registry()
.return_const(false);
let mut reader2 = MockReader::new();
reader2
.expect_supports_revocation_registry()
.return_const(true);
let return_def = rev_reg_def.clone();
let return_meta = meta.clone();
reader2
.expect_get_rev_reg_def_json()
.times(1)
.with(eq(id.clone()))
.return_once(move |_| Ok((return_def, return_meta)));
let reader = MultiLedgerAnoncredsRead::new()
.register_reader(reader1)
.register_reader(reader2);
let (actual_def, actual_meta) = reader.get_rev_reg_def_json(&id).await.unwrap();
assert_eq!(
serde_json::to_value(actual_def).unwrap(),
serde_json::to_value(rev_reg_def).unwrap()
);
assert_eq!(
serde_json::to_value(actual_meta).unwrap(),
serde_json::to_value(meta).unwrap()
);
}
#[tokio::test]
async fn test_get_rev_status_list_proxy() {
let id = RevocationRegistryDefinitionId::new_unchecked(uuid::Uuid::new_v4().to_string());
let input_timestamp = 978;
let meta = json!({
"foo": "bar",
uuid::Uuid::new_v4().to_string(): [uuid::Uuid::new_v4().to_string()],
});
let rev_status_list: RevocationStatusList = serde_json::from_value(json!({
"issuerId": "did:cheqd:testnet:8bbd2026-03f5-42c7-bf80-09f46fc4d67b",
"revRegDefId": "4xE68b6S5VRFrKMMG1U95M:4:4xE68b6S5VRFrKMMG1U95M:3:CL:59232:default:CL_ACCUM:4ae1cc6c-f6bd-486c-8057-88f2ce74e960",
"revocationList": [0, 1, 1, 0],
"currentAccumulator": "21 124C594B6B20E41B681E92B2C43FD165EA9E68BC3C9D63A82C8893124983CAE94 21 124C5341937827427B0A3A32113BD5E64FB7AB39BD3E5ABDD7970874501CA4897 6 5438CB6F442E2F807812FD9DC0C39AFF4A86B1E6766DBB5359E86A4D70401B0F 4 39D1CA5C4716FFC4FE0853C4FF7F081DFD8DF8D2C2CA79705211680AC77BF3A1 6 70504A5493F89C97C225B68310811A41AD9CD889301F238E93C95AD085E84191 4 39582252194D756D5D86D0EED02BF1B95CE12AED2FA5CD3C53260747D891993C",
"timestamp": 1669640864
}))
.unwrap();
let output_timestamp = 876;
let mut reader1 = MockReader::new();
reader1
.expect_supports_revocation_registry()
.return_const(false);
let mut reader2 = MockReader::new();
reader2
.expect_supports_revocation_registry()
.return_const(true);
let return_list = rev_status_list.clone();
let expected_id = id.clone();
let expected_meta = meta.clone();
reader2
.expect_get_rev_status_list()
.times(1)
.withf(move |id, ts, meta| {
id == &expected_id && ts == &input_timestamp && meta == &Some(&expected_meta)
})
.return_once(move |_, _, _| {
Box::pin(async move { Ok((return_list, output_timestamp)) })
});
let reader = MultiLedgerAnoncredsRead::new()
.register_reader(reader1)
.register_reader(reader2);
let (actual_list, actual_timestamp) = reader
.get_rev_status_list(&id, input_timestamp, Some(&meta))
.await
.unwrap();
assert_eq!(
serde_json::to_value(actual_list).unwrap(),
serde_json::to_value(rev_status_list).unwrap()
);
assert_eq!(
| rust | Apache-2.0 | 2d3034ed73ba8d49e0f72251b4c7cfb859a1efe7 | 2026-01-04T20:24:59.602734Z | true |
openwallet-foundation/vcx | https://github.com/openwallet-foundation/vcx/blob/2d3034ed73ba8d49e0f72251b4c7cfb859a1efe7/aries/aries_vcx_ledger/src/ledger/indy_vdr_ledger.rs | aries/aries_vcx_ledger/src/ledger/indy_vdr_ledger.rs | use std::{
fmt::{Debug, Formatter},
str::FromStr,
sync::RwLock,
};
use anoncreds_types::{
data_types::{
identifiers::{
cred_def_id::CredentialDefinitionId, issuer_id::IssuerId,
rev_reg_def_id::RevocationRegistryDefinitionId, schema_id::SchemaId,
},
ledger::{
cred_def::CredentialDefinition, rev_reg::RevocationRegistry,
rev_reg_def::RevocationRegistryDefinition, rev_reg_delta::RevocationRegistryDelta,
rev_status_list::RevocationStatusList, schema::Schema,
},
},
utils::conversions::from_revocation_registry_delta_to_revocation_status_list,
};
use aries_vcx_wallet::wallet::base_wallet::BaseWallet;
use async_trait::async_trait;
use did_parser_nom::Did;
pub use indy_ledger_response_parser::GetTxnAuthorAgreementData;
use indy_ledger_response_parser::{
ResponseParser, RevocationRegistryDeltaInfo, RevocationRegistryInfo,
};
use indy_vdr::{
self as vdr,
ledger::{
identifiers::SchemaId as IndyVdrSchemaId,
requests::cred_def::CredentialDefinition as IndyVdrCredentialDefinition,
},
utils::{did::DidValue, Validatable},
};
use log::{debug, trace};
use public_key::Key;
use serde::{Deserialize, Serialize};
use serde_json::{json, Value};
use time::OffsetDateTime;
use vdr::{
config::PoolConfig,
ledger::{
identifiers::{
CredentialDefinitionId as IndyVdrCredentialDefinitionId, RevocationRegistryId,
},
requests::rev_reg_def::RegistryType,
RequestBuilder,
},
pool::{LedgerType, PreparedRequest},
utils::Qualifiable,
};
pub use vdr::{
ledger::constants::{LedgerRole, UpdateRole},
pool::ProtocolVersion,
};
use super::{
base_ledger::{
AnoncredsLedgerRead, AnoncredsLedgerSupport, AnoncredsLedgerWrite, IndyLedgerRead,
IndyLedgerWrite,
},
map_error_not_found_to_none,
request_submitter::{
vdr_ledger::{IndyVdrLedgerPool, IndyVdrSubmitter},
RequestSubmitter,
},
response_cacher::{
in_memory::{InMemoryResponseCacher, InMemoryResponseCacherConfig},
ResponseCacher,
},
};
use crate::{
errors::error::{VcxLedgerError, VcxLedgerResult},
ledger::{
base_ledger::{TaaConfigurator, TxnAuthrAgrmtOptions},
common::verify_transaction_can_be_endorsed,
type_conversion::Convert,
},
};
pub type DefaultIndyLedgerRead = IndyVdrLedgerRead<IndyVdrSubmitter, InMemoryResponseCacher>;
pub type DefaultIndyLedgerWrite = IndyVdrLedgerWrite<IndyVdrSubmitter>;
// TODO: Should implement builders for these configs...
// Good first issue?
pub struct IndyVdrLedgerReadConfig<T, V>
where
T: RequestSubmitter + Send + Sync,
V: ResponseCacher + Send + Sync,
{
pub request_submitter: T,
pub response_parser: ResponseParser,
pub response_cacher: V,
pub protocol_version: ProtocolVersion,
}
pub struct IndyVdrLedgerWriteConfig<T>
where
T: RequestSubmitter + Send + Sync,
{
pub request_submitter: T,
pub taa_options: Option<TxnAuthrAgrmtOptions>,
pub protocol_version: ProtocolVersion,
}
pub struct IndyVdrLedgerRead<T, V>
where
T: RequestSubmitter + Send + Sync,
V: ResponseCacher + Send + Sync,
{
request_submitter: T,
response_parser: ResponseParser,
response_cacher: V,
protocol_version: ProtocolVersion,
}
pub struct IndyVdrLedgerWrite<T>
where
T: RequestSubmitter + Send + Sync,
{
request_submitter: T,
taa_options: RwLock<Option<TxnAuthrAgrmtOptions>>,
protocol_version: ProtocolVersion,
}
impl<T, V> IndyVdrLedgerRead<T, V>
where
T: RequestSubmitter + Send + Sync,
V: ResponseCacher + Send + Sync,
{
pub fn new(config: IndyVdrLedgerReadConfig<T, V>) -> Self {
Self {
request_submitter: config.request_submitter,
response_parser: config.response_parser,
response_cacher: config.response_cacher,
protocol_version: config.protocol_version,
}
}
pub fn request_builder(&self) -> VcxLedgerResult<RequestBuilder> {
Ok(RequestBuilder::new(self.protocol_version))
}
async fn submit_request(
&self,
cache_id: Option<&str>,
request: PreparedRequest,
) -> VcxLedgerResult<String> {
trace!(
"submit_request >> Submitting ledger request, cache_id: {cache_id:?}, request: \
{request:?}"
);
let (response, is_from_cache) = match cache_id {
Some(cache_id) => match self.response_cacher.get(cache_id, None).await? {
Some(response) => {
trace!("submit_request << Returning cached response");
(response, true)
}
None => {
trace!(
"submit_request << cache miss, will make ledger request. Response will be \
cached."
);
let response = self.request_submitter.submit(request).await?;
self.response_cacher.put(cache_id, response.clone()).await?;
(response, false)
}
},
None => {
trace!("submit_request << caching is disabled for this request");
let response = self.request_submitter.submit(request).await?;
(response, false)
}
};
trace!("submit_request << ledger response (is from cache: {is_from_cache}): {response}");
Ok(response)
}
async fn resolve_schema_id_from_seq_no(
&self,
seq_no: i32,
submitter_did: Option<&Did>,
) -> VcxLedgerResult<IndyVdrSchemaId> {
let response = self.get_ledger_txn(seq_no, submitter_did).await?;
let mut txn_response = self.response_parser.parse_get_txn_response(&response)?;
let txn = txn_response["txn"].take();
// mimic acapy & credo-ts behaviour - assumes node protocol >= 1.4
// check correct tx
let txn_type = &txn["type"];
if txn_type != &json!("101") {
return Err(VcxLedgerError::InvalidLedgerResponse(format!(
"Expected indy schema transaction type (101), found: {txn_type}"
)));
}
// pull schema identifier parts
let schema_did = &txn["metadata"]["from"];
let schema_name = &txn["data"]["data"]["name"];
let schema_version = &txn["data"]["data"]["version"];
let (Value::String(did), Value::String(name), Value::String(ver)) =
(schema_did, schema_name, schema_version)
else {
return Err(VcxLedgerError::InvalidLedgerResponse(
"Could not resolve schema DID, name & version from txn".into(),
));
};
// construct indy schema ID from parts
let did = DidValue::new(did, None);
did.validate()?;
let schema_id = IndyVdrSchemaId::new(&did, name, ver);
schema_id.validate()?;
Ok(schema_id)
}
}
impl<T> IndyVdrLedgerWrite<T>
where
T: RequestSubmitter + Send + Sync,
{
pub fn new(config: IndyVdrLedgerWriteConfig<T>) -> Self {
Self {
request_submitter: config.request_submitter,
taa_options: RwLock::new(None),
protocol_version: config.protocol_version,
}
}
pub fn request_builder(&self) -> VcxLedgerResult<RequestBuilder> {
Ok(RequestBuilder::new(self.protocol_version))
}
async fn sign_request(
wallet: &impl BaseWallet,
did: &Did,
request: &PreparedRequest,
) -> VcxLedgerResult<Vec<u8>> {
let to_sign = request.get_signature_input()?;
let signer_verkey = wallet.key_for_did(&did.to_string()).await?;
let signature = wallet.sign(&signer_verkey, to_sign.as_bytes()).await?;
Ok(signature)
}
async fn sign_and_submit_request(
&self,
wallet: &impl BaseWallet,
submitter_did: &Did,
request: PreparedRequest,
) -> VcxLedgerResult<String> {
let mut request = request;
let signature = Self::sign_request(wallet, submitter_did, &request).await?;
request.set_signature(&signature)?;
self.request_submitter.submit(request).await
}
}
impl<T> TaaConfigurator for IndyVdrLedgerWrite<T>
where
T: RequestSubmitter + Send + Sync,
{
fn set_txn_author_agreement_options(
&self,
taa_options: TxnAuthrAgrmtOptions,
) -> VcxLedgerResult<()> {
let mut m = self.taa_options.write()?;
*m = Some(taa_options);
Ok(())
}
fn get_txn_author_agreement_options(&self) -> VcxLedgerResult<Option<TxnAuthrAgrmtOptions>> {
Ok(self.taa_options.read()?.clone())
}
}
impl<T, V> Debug for IndyVdrLedgerRead<T, V>
where
T: RequestSubmitter + Send + Sync,
V: ResponseCacher + Send + Sync,
{
fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
write!(f, "IndyVdrLedgerRead instance")
}
}
impl<T> Debug for IndyVdrLedgerWrite<T>
where
T: RequestSubmitter + Send + Sync,
{
fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
write!(f, "IndyVdrLedgerWrite instance")
}
}
#[async_trait]
impl<T, V> IndyLedgerRead for IndyVdrLedgerRead<T, V>
where
T: RequestSubmitter + Send + Sync,
V: ResponseCacher + Send + Sync,
{
async fn get_attr(&self, target_did: &Did, attr_name: &str) -> VcxLedgerResult<String> {
debug!("get_attr >> target_did: {target_did}, attr_name: {attr_name}");
let request = self.request_builder()?.build_get_attrib_request(
None,
&target_did.convert(())?,
Some(attr_name.to_string()),
None,
None,
None,
None,
)?;
let response = self.submit_request(None, request).await?;
debug!("get_attr << response: {response}");
Ok(response)
}
async fn get_nym(&self, did: &Did) -> VcxLedgerResult<String> {
debug!("get_nym >> did: {did}");
let request =
self.request_builder()?
.build_get_nym_request(None, &did.convert(())?, None, None)?;
let response = self.submit_request(None, request).await?;
debug!("get_nym << response: {response}");
Ok(response)
}
async fn get_txn_author_agreement(&self) -> VcxLedgerResult<Option<String>> {
debug!("get_txn_author_agreement >>");
let request = self
.request_builder()?
.build_get_txn_author_agreement_request(None, None)?;
let response = self.submit_request(None, request).await?;
debug!("get_txn_author_agreement << response: {response}");
map_error_not_found_to_none(
self.response_parser
.parse_get_txn_author_agreement_response(&response),
)?
.map(|taa| serde_json::to_string(&taa).map_err(Into::into))
.transpose()
}
async fn get_ledger_txn(
&self,
seq_no: i32,
submitter_did: Option<&Did>,
) -> VcxLedgerResult<String> {
debug!("get_ledger_txn >> seq_no: {seq_no}");
let identifier = submitter_did.map(|did| did.convert(())).transpose()?;
let request = self.request_builder()?.build_get_txn_request(
identifier.as_ref(),
LedgerType::DOMAIN.to_id(),
seq_no,
)?;
let response = self.submit_request(None, request).await?;
debug!("get_ledger_txn << response: {response}");
Ok(response)
}
}
impl<T> IndyVdrLedgerWrite<T>
where
T: RequestSubmitter + Send + Sync,
{
async fn append_txn_author_agreement_to_request(
&self,
request: PreparedRequest,
) -> VcxLedgerResult<PreparedRequest> {
let taa_options = (*self.taa_options.read()?).clone();
if let Some(taa_options) = taa_options {
let mut request = request;
let taa_data = self
.request_builder()?
.prepare_txn_author_agreement_acceptance_data(
Some(&taa_options.text),
Some(&taa_options.version),
None,
&taa_options.mechanism,
OffsetDateTime::now_utc().unix_timestamp() as u64,
)?;
request.set_txn_author_agreement_acceptance(&taa_data)?;
Ok(request)
} else {
Ok(request)
}
}
}
#[async_trait]
impl<T> IndyLedgerWrite for IndyVdrLedgerWrite<T>
where
T: RequestSubmitter + Send + Sync,
{
async fn publish_nym(
&self,
wallet: &impl BaseWallet,
submitter_did: &Did,
target_did: &Did,
verkey: Option<&Key>,
data: Option<&str>,
role: Option<&str>,
) -> VcxLedgerResult<String> {
let identifier = submitter_did.convert(())?;
let dest = target_did.convert(())?;
let request = self.request_builder()?.build_nym_request(
&identifier,
&dest,
verkey.map(Key::base58),
data.map(String::from),
role.map(UpdateRole::from_str).transpose()?,
None,
None,
)?;
let request = self.append_txn_author_agreement_to_request(request).await?;
self.sign_and_submit_request(wallet, submitter_did, request)
.await
}
async fn set_endorser(
&self,
wallet: &impl BaseWallet,
submitter_did: &Did,
request_json: &str,
endorser: &Did,
) -> VcxLedgerResult<String> {
let mut request = PreparedRequest::from_request_json(request_json)?;
request.set_endorser(&endorser.convert(())?)?;
let signature_submitter = Self::sign_request(wallet, submitter_did, &request).await?;
request.set_multi_signature(&submitter_did.convert(())?, &signature_submitter)?;
Ok(request.req_json.to_string())
}
async fn endorse_transaction(
&self,
wallet: &impl BaseWallet,
endorser_did: &Did,
request_json: &str,
) -> VcxLedgerResult<()> {
let mut request = PreparedRequest::from_request_json(request_json)?;
verify_transaction_can_be_endorsed(request_json, endorser_did)?;
let signature_endorser = Self::sign_request(wallet, endorser_did, &request).await?;
request.set_multi_signature(&endorser_did.convert(())?, &signature_endorser)?;
self.request_submitter.submit(request).await.map(|_| ())
}
async fn add_attr(
&self,
wallet: &impl BaseWallet,
target_did: &Did,
attrib_json: &str,
) -> VcxLedgerResult<String> {
let identifier = target_did.convert(())?;
let dest = target_did.convert(())?;
let request = self.request_builder()?.build_attrib_request(
&identifier,
&dest,
None,
Some(&serde_json::from_str::<Value>(attrib_json)?),
None,
)?;
let request = self.append_txn_author_agreement_to_request(request).await?;
self.sign_and_submit_request(wallet, target_did, request)
.await
}
async fn write_did(
&self,
wallet: &impl BaseWallet,
submitter_did: &Did,
target_did: &Did,
target_vk: &Key,
role: Option<UpdateRole>,
alias: Option<String>,
) -> VcxLedgerResult<String> {
debug!(
"write_did >> submitter_did: {submitter_did}, target_did: {target_did}, target_vk: \
{target_vk:?}, role: {role:?}, alias: {alias:?}"
);
let request = self.request_builder()?.build_nym_request(
&submitter_did.convert(())?,
&target_did.convert(())?,
Some(target_vk.base58()),
alias,
role,
None,
None,
)?;
let request = self.append_txn_author_agreement_to_request(request).await?;
let response = self
.sign_and_submit_request(wallet, submitter_did, request)
.await?;
debug!("write_did << response: {response}");
return Ok(response);
}
}
#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct RevocationRegistryDefinitionAdditionalMetadata {
pub max_cred_num: usize,
pub issuer_id: IssuerId,
}
#[async_trait]
impl<T, V> AnoncredsLedgerRead for IndyVdrLedgerRead<T, V>
where
T: RequestSubmitter + Send + Sync,
V: ResponseCacher + Send + Sync,
{
type RevocationRegistryDefinitionAdditionalMetadata =
RevocationRegistryDefinitionAdditionalMetadata;
async fn get_schema(
&self,
schema_id: &SchemaId,
_submitter_did: Option<&Did>,
) -> VcxLedgerResult<Schema> {
debug!("get_schema >> schema_id: {schema_id}");
let request = self
.request_builder()?
.build_get_schema_request(None, &schema_id.convert(())?)?;
let response = self.submit_request(None, request).await?;
debug!("get_schema << response: {response}");
let schema = self
.response_parser
.parse_get_schema_response(&response, None)?;
Ok(schema.convert(())?)
}
async fn get_cred_def(
&self,
cred_def_id: &CredentialDefinitionId,
submitter_did: Option<&Did>,
) -> VcxLedgerResult<CredentialDefinition> {
debug!("get_cred_def >> cred_def_id: {cred_def_id}");
let identifier = submitter_did.map(|did| did.convert(())).transpose()?;
let id = IndyVdrCredentialDefinitionId::from_str(&cred_def_id.to_string())?;
let request = self
.request_builder()?
.build_get_cred_def_request(identifier.as_ref(), &id)?;
// note: Before we try to create credential definition, we are checking if it already
// doesn't exist on the ledger to prevent invalidating the old one.
// When we make the first request, it typically doesn't exist, but we don't want to
// cache such as result. So caching strategy should perhaps only store data in cache
// if ledger response was found / the response is success.
// Therefore parsing should happen prior to caching.
let response = self.submit_request(None, request).await?;
debug!("get_cred_def << response: {response}");
let cred_def = self
.response_parser
.parse_get_cred_def_response(&response, None)?;
// extract and map seqNo -> schemaId if required
let IndyVdrCredentialDefinition::CredentialDefinitionV1(mut cred_def) = cred_def;
if let Ok(seq_no) = cred_def.schema_id.0.parse::<i32>() {
cred_def.schema_id = self
.resolve_schema_id_from_seq_no(seq_no, submitter_did)
.await?;
}
let cred_def = IndyVdrCredentialDefinition::CredentialDefinitionV1(cred_def).convert(())?;
Ok(cred_def)
}
async fn get_rev_reg_def_json(
&self,
rev_reg_id: &RevocationRegistryDefinitionId,
) -> VcxLedgerResult<(
RevocationRegistryDefinition,
RevocationRegistryDefinitionAdditionalMetadata,
)> {
debug!("get_rev_reg_def_json >> rev_reg_id: {rev_reg_id}");
let id = RevocationRegistryId::from_str(&rev_reg_id.to_string())?;
let request = self
.request_builder()?
.build_get_revoc_reg_def_request(None, &id)?;
let response = self
.submit_request(Some(&rev_reg_id.to_string()), request)
.await?;
debug!("get_rev_reg_def_json << response: {response}");
let rev_reg_def = self
.response_parser
.parse_get_revoc_reg_def_response(&response)?;
let def = rev_reg_def.convert(())?;
let meta = RevocationRegistryDefinitionAdditionalMetadata {
max_cred_num: def.value.max_cred_num as usize,
issuer_id: def.issuer_id.clone(),
};
Ok((def, meta))
}
async fn get_rev_reg_delta_json(
&self,
rev_reg_id: &RevocationRegistryDefinitionId,
from: Option<u64>,
to: Option<u64>,
) -> VcxLedgerResult<(RevocationRegistryDelta, u64)> {
debug!("get_rev_reg_delta_json >> rev_reg_id: {rev_reg_id}, from: {from:?}, to: {to:?}");
let revoc_reg_def_id = RevocationRegistryId::from_str(&rev_reg_id.to_string())?;
let from = from.map(|x| x as i64);
let current_time = OffsetDateTime::now_utc().unix_timestamp();
let to = to.map_or(current_time, |x| x as i64);
let request = self.request_builder()?.build_get_revoc_reg_delta_request(
None,
&revoc_reg_def_id,
from,
to,
)?;
let response = self.submit_request(None, request).await?;
debug!("get_rev_reg_delta_json << response: {response}");
let RevocationRegistryDeltaInfo {
revoc_reg_delta,
timestamp,
..
} = self
.response_parser
.parse_get_revoc_reg_delta_response(&response)?;
Ok((revoc_reg_delta.convert(())?, timestamp))
}
async fn get_rev_status_list(
&self,
rev_reg_id: &RevocationRegistryDefinitionId,
timestamp: u64,
rev_reg_def_meta: Option<&RevocationRegistryDefinitionAdditionalMetadata>,
) -> VcxLedgerResult<(RevocationStatusList, u64)> {
#[allow(deprecated)] // TODO - https://github.com/openwallet-foundation/vcx/issues/1309
let (delta, entry_time) = self
.get_rev_reg_delta_json(rev_reg_id, Some(0), Some(timestamp))
.await?;
let rev_reg_def_meta = match rev_reg_def_meta {
Some(x) => x,
None => &self.get_rev_reg_def_json(rev_reg_id).await?.1,
};
let status_list = from_revocation_registry_delta_to_revocation_status_list(
&delta.value,
entry_time,
rev_reg_id,
rev_reg_def_meta.max_cred_num,
rev_reg_def_meta.issuer_id.clone(),
)
.map_err(|e| {
VcxLedgerError::InvalidLedgerResponse(format!(
"received rev status delta could not be translated to status list: {e} {delta:?}"
))
})?;
Ok((status_list, entry_time))
}
async fn get_rev_reg(
&self,
rev_reg_id: &RevocationRegistryDefinitionId,
timestamp: u64,
) -> VcxLedgerResult<(RevocationRegistry, u64)> {
debug!("get_rev_reg >> rev_reg_id: {rev_reg_id}, timestamp: {timestamp}");
let revoc_reg_def_id = RevocationRegistryId::from_str(&rev_reg_id.to_string())?;
let request = self.request_builder()?.build_get_revoc_reg_request(
None,
&revoc_reg_def_id,
timestamp.try_into().unwrap(),
)?;
let response = self.submit_request(None, request).await?;
debug!("get_rev_reg << response: {response}");
let RevocationRegistryInfo {
revoc_reg,
timestamp,
..
} = self
.response_parser
.parse_get_revoc_reg_response(&response)?;
Ok((revoc_reg.convert(())?, timestamp))
}
}
impl<T: RequestSubmitter, V: ResponseCacher> AnoncredsLedgerSupport for IndyVdrLedgerRead<T, V> {
fn supports_schema(&self, id: &SchemaId) -> bool {
if id.is_legacy() {
// unqualified
return true;
}
did_method_is_supported(&id.0)
}
fn supports_credential_definition(&self, id: &CredentialDefinitionId) -> bool {
if id.is_legacy_cred_def_identifier() {
// unqualified
return true;
}
did_method_is_supported(&id.0)
}
fn supports_revocation_registry(&self, id: &RevocationRegistryDefinitionId) -> bool {
if id.is_legacy() {
// unqualified
return true;
}
did_method_is_supported(&id.0)
}
}
fn did_method_is_supported(id: &str) -> bool {
let is_sov = id.starts_with("did:sov:");
let is_unqualified = !id.starts_with("did");
// FUTURE - indy & namespace
is_sov || is_unqualified
}
#[async_trait]
impl<T> AnoncredsLedgerWrite for IndyVdrLedgerWrite<T>
where
T: RequestSubmitter + Send + Sync,
{
async fn publish_schema(
&self,
wallet: &impl BaseWallet,
schema_json: Schema,
submitter_did: &Did,
_endorser_did: Option<&Did>,
) -> VcxLedgerResult<()> {
let identifier = submitter_did.convert(())?;
let mut request = self
.request_builder()?
.build_schema_request(&identifier, schema_json.convert(())?)?;
request = self.append_txn_author_agreement_to_request(request).await?;
// if let Some(endorser_did) = endorser_did {
// request = PreparedRequest::from_request_json(
// self.set_endorser(submitter_did, &request.req_json.to_string(), &endorser_did)
// .await?,
// )?
// }
let sign_result = self
.sign_and_submit_request(wallet, submitter_did, request)
.await;
if matches!(sign_result, Err(VcxLedgerError::InvalidLedgerResponse(_))) {
return Err(VcxLedgerError::DuplicationSchema);
}
sign_result.map(|_| ())
}
async fn publish_cred_def(
&self,
wallet: &impl BaseWallet,
cred_def_json: CredentialDefinition,
submitter_did: &Did,
) -> VcxLedgerResult<()> {
let identifier = submitter_did.convert(())?;
let request = self
.request_builder()?
.build_cred_def_request(&identifier, cred_def_json.convert(())?)?;
let request = self.append_txn_author_agreement_to_request(request).await?;
self.sign_and_submit_request(wallet, submitter_did, request)
.await
.map(|_| ())
}
async fn publish_rev_reg_def(
&self,
wallet: &impl BaseWallet,
rev_reg_def: RevocationRegistryDefinition,
submitter_did: &Did,
) -> VcxLedgerResult<()> {
let identifier = submitter_did.convert(())?;
let request = self
.request_builder()?
.build_revoc_reg_def_request(&identifier, rev_reg_def.convert(())?)?;
let request = self.append_txn_author_agreement_to_request(request).await?;
self.sign_and_submit_request(wallet, submitter_did, request)
.await
.map(|_| ())
}
async fn publish_rev_reg_delta(
&self,
wallet: &impl BaseWallet,
rev_reg_id: &RevocationRegistryDefinitionId,
rev_reg_entry_json: RevocationRegistryDelta,
submitter_did: &Did,
) -> VcxLedgerResult<()> {
let identifier = submitter_did.convert(())?;
let request = self.request_builder()?.build_revoc_reg_entry_request(
&identifier,
&RevocationRegistryId::from_str(&rev_reg_id.to_string())?,
&RegistryType::CL_ACCUM,
rev_reg_entry_json.convert(())?,
)?;
let request = self.append_txn_author_agreement_to_request(request).await?;
self.sign_and_submit_request(wallet, submitter_did, request)
.await
.map(|_| ())
}
}
pub fn indyvdr_build_ledger_read(
request_submitter: IndyVdrSubmitter,
cache_config: InMemoryResponseCacherConfig,
) -> VcxLedgerResult<IndyVdrLedgerRead<IndyVdrSubmitter, InMemoryResponseCacher>> {
let response_parser = ResponseParser;
let response_cacher = InMemoryResponseCacher::new(cache_config);
let config_read = IndyVdrLedgerReadConfig {
request_submitter,
response_parser,
response_cacher,
protocol_version: ProtocolVersion::Node1_4,
};
Ok(IndyVdrLedgerRead::new(config_read))
}
pub fn indyvdr_build_ledger_write(
request_submitter: IndyVdrSubmitter,
taa_options: Option<TxnAuthrAgrmtOptions>,
) -> IndyVdrLedgerWrite<IndyVdrSubmitter> {
let config_write = IndyVdrLedgerWriteConfig {
request_submitter,
taa_options,
protocol_version: ProtocolVersion::Node1_4,
};
IndyVdrLedgerWrite::new(config_write)
}
#[derive(Clone)]
pub struct VcxPoolConfig {
pub genesis_file_path: String,
pub indy_vdr_config: Option<PoolConfig>,
pub response_cache_config: Option<InMemoryResponseCacherConfig>,
}
pub fn build_ledger_components(
pool_config: VcxPoolConfig,
) -> VcxLedgerResult<(DefaultIndyLedgerRead, DefaultIndyLedgerWrite)> {
let indy_vdr_config = pool_config.indy_vdr_config.unwrap_or_default();
let cache_config = match pool_config.response_cache_config {
None => InMemoryResponseCacherConfig::builder()
.ttl(std::time::Duration::from_secs(60))
.capacity(1000)?
.build(),
Some(cfg) => cfg,
};
let ledger_pool =
IndyVdrLedgerPool::new(pool_config.genesis_file_path, indy_vdr_config, vec![])?;
let request_submitter = IndyVdrSubmitter::new(ledger_pool);
let ledger_read = indyvdr_build_ledger_read(request_submitter.clone(), cache_config)?;
let ledger_write = indyvdr_build_ledger_write(request_submitter, None);
Ok((ledger_read, ledger_write))
}
#[cfg(test)]
mod unit_tests {
use mockall::mock;
use super::*;
use crate::ledger::response_cacher::noop::NoopResponseCacher;
mock! {
pub RequestSubmitter {}
#[async_trait]
impl RequestSubmitter for RequestSubmitter {
async fn submit(&self, request: indy_vdr::pool::PreparedRequest) -> VcxLedgerResult<String>;
}
}
fn dummy_indy_vdr_reader() -> IndyVdrLedgerRead<MockRequestSubmitter, NoopResponseCacher> {
IndyVdrLedgerRead::new(IndyVdrLedgerReadConfig {
request_submitter: MockRequestSubmitter::new(),
response_parser: indy_ledger_response_parser::ResponseParser,
response_cacher: NoopResponseCacher,
protocol_version: ProtocolVersion::Node1_4,
})
}
#[test]
fn test_anoncreds_schema_support() {
let reader = dummy_indy_vdr_reader();
// legacy
assert!(reader.supports_schema(
&SchemaId::new("7BPMqYgYLQni258J8JPS8K:2:degree schema:46.58.87").unwrap()
));
// qualified sov
assert!(reader.supports_schema(
&SchemaId::new("did:sov:7BPMqYgYLQni258J8JPS8K:2:degree schema:46.58.87").unwrap()
));
// qualified cheqd
assert!(!reader.supports_schema(
&SchemaId::new(
"did:cheqd:mainnet:7BPMqYgYLQni258J8JPS8K/resources/\
6259d357-eeb1-4b98-8bee-12a8390d3497"
)
.unwrap()
));
}
#[test]
fn test_anoncreds_cred_def_support() {
let reader = dummy_indy_vdr_reader();
// legacy
assert!(reader.supports_credential_definition(
&CredentialDefinitionId::new(
"7BPMqYgYLQni258J8JPS8K:3:CL:70:faber.agent.degree_schema"
)
.unwrap()
));
// qualified sov
assert!(reader.supports_credential_definition(
&CredentialDefinitionId::new(
"did:sov:7BPMqYgYLQni258J8JPS8K:3:CL:70:faber.agent.degree_schema"
)
.unwrap()
));
// qualified cheqd
assert!(!reader.supports_credential_definition(
&CredentialDefinitionId::new(
"did:cheqd:mainnet:7BPMqYgYLQni258J8JPS8K/resources/\
6259d357-eeb1-4b98-8bee-12a8390d3497"
)
.unwrap()
));
}
#[test]
fn test_anoncreds_rev_reg_support() {
let reader = dummy_indy_vdr_reader();
// legacy
assert!(reader.supports_revocation_registry(
&RevocationRegistryDefinitionId::new(
"7BPMqYgYLQni258J8JPS8K:4:7BPMqYgYLQni258J8JPS8K:3:CL:70:faber.agent.\
degree_schema:CL_ACCUM:61d5a381-30be-4120-9307-b150b49c203c"
)
.unwrap()
));
// qualified sov
assert!(reader.supports_revocation_registry(
&RevocationRegistryDefinitionId::new(
"did:sov:7BPMqYgYLQni258J8JPS8K:4:7BPMqYgYLQni258J8JPS8K:3:CL:70:faber.agent.\
degree_schema:CL_ACCUM:61d5a381-30be-4120-9307-b150b49c203c"
)
.unwrap()
));
// qualified cheqd
assert!(!reader.supports_revocation_registry(
&RevocationRegistryDefinitionId::new(
"did:cheqd:mainnet:7BPMqYgYLQni258J8JPS8K/resources/\
| rust | Apache-2.0 | 2d3034ed73ba8d49e0f72251b4c7cfb859a1efe7 | 2026-01-04T20:24:59.602734Z | true |
openwallet-foundation/vcx | https://github.com/openwallet-foundation/vcx/blob/2d3034ed73ba8d49e0f72251b4c7cfb859a1efe7/aries/aries_vcx_ledger/src/ledger/mod.rs | aries/aries_vcx_ledger/src/ledger/mod.rs | use crate::errors::error::VcxLedgerError;
pub mod arc;
pub mod base_ledger;
pub mod common;
#[cfg(feature = "cheqd")]
pub mod cheqd;
pub mod indy;
pub mod indy_vdr_ledger;
pub mod multi_ledger;
mod type_conversion;
pub mod request_submitter;
pub mod response_cacher;
fn map_error_not_found_to_none<T, E>(res: Result<T, E>) -> Result<Option<T>, VcxLedgerError>
where
E: Into<VcxLedgerError>,
{
match res {
Ok(response) => Ok(Some(response)),
Err(err) => {
let err_converted = Into::<VcxLedgerError>::into(err);
match err_converted {
VcxLedgerError::LedgerItemNotFound => Ok(None),
_ => Err(err_converted),
}
}
}
}
| rust | Apache-2.0 | 2d3034ed73ba8d49e0f72251b4c7cfb859a1efe7 | 2026-01-04T20:24:59.602734Z | false |
openwallet-foundation/vcx | https://github.com/openwallet-foundation/vcx/blob/2d3034ed73ba8d49e0f72251b4c7cfb859a1efe7/aries/aries_vcx_ledger/src/ledger/common.rs | aries/aries_vcx_ledger/src/ledger/common.rs | use std::collections::HashMap;
use did_parser_nom::Did;
use serde::Deserialize;
use crate::errors::error::{VcxLedgerError, VcxLedgerResult};
#[derive(Deserialize, Debug)]
#[serde(rename_all = "camelCase")]
struct Request {
#[allow(dead_code)]
pub req_id: u64,
pub identifier: String,
pub signature: Option<String>,
pub signatures: Option<HashMap<String, String>>,
pub endorser: Option<String>,
}
pub fn verify_transaction_can_be_endorsed(
transaction_json: &str,
submitter_did: &Did,
) -> VcxLedgerResult<()> {
let transaction: Request = serde_json::from_str(transaction_json)?;
let endorser_did = transaction.endorser.ok_or(VcxLedgerError::InvalidState(
"Transaction cannot be endorsed: endorser DID is not set.".into(),
))?;
if &Did::parse(endorser_did.clone())? != submitter_did {
return Err(VcxLedgerError::InvalidState(format!(
"Transaction cannot be endorsed: transaction endorser DID `{endorser_did}` and sender \
DID `{submitter_did}` are different"
)));
}
let identifier = transaction.identifier.as_str();
if transaction.signature.is_none()
&& !transaction
.signatures
.as_ref()
.map(|signatures| signatures.contains_key(identifier))
.unwrap_or(false)
{
return Err(VcxLedgerError::InvalidState(
"Transaction cannot be endorsed: the author must sign the transaction.".to_string(),
));
}
Ok(())
}
| rust | Apache-2.0 | 2d3034ed73ba8d49e0f72251b4c7cfb859a1efe7 | 2026-01-04T20:24:59.602734Z | false |
openwallet-foundation/vcx | https://github.com/openwallet-foundation/vcx/blob/2d3034ed73ba8d49e0f72251b4c7cfb859a1efe7/aries/aries_vcx_ledger/src/ledger/base_ledger.rs | aries/aries_vcx_ledger/src/ledger/base_ledger.rs | use std::fmt::Debug;
use anoncreds_types::data_types::{
identifiers::{
cred_def_id::CredentialDefinitionId, rev_reg_def_id::RevocationRegistryDefinitionId,
schema_id::SchemaId,
},
ledger::{
cred_def::CredentialDefinition, rev_reg::RevocationRegistry,
rev_reg_def::RevocationRegistryDefinition, rev_reg_delta::RevocationRegistryDelta,
rev_status_list::RevocationStatusList, schema::Schema,
},
};
use aries_vcx_wallet::wallet::base_wallet::BaseWallet;
use async_trait::async_trait;
use did_parser_nom::Did;
use indy_vdr::ledger::constants::UpdateRole;
use public_key::Key;
use serde::Serialize;
use crate::errors::error::VcxLedgerResult;
#[async_trait]
pub trait IndyLedgerRead: Debug + Send + Sync {
async fn get_attr(&self, target_did: &Did, attr_name: &str) -> VcxLedgerResult<String>;
async fn get_nym(&self, did: &Did) -> VcxLedgerResult<String>;
async fn get_txn_author_agreement(&self) -> VcxLedgerResult<Option<String>>;
async fn get_ledger_txn(
&self,
seq_no: i32,
submitter_did: Option<&Did>,
) -> VcxLedgerResult<String>;
}
#[async_trait]
pub trait IndyLedgerWrite: Debug + Send + Sync {
async fn publish_nym(
&self,
wallet: &impl BaseWallet,
submitter_did: &Did,
target_did: &Did,
verkey: Option<&Key>,
data: Option<&str>,
role: Option<&str>,
) -> VcxLedgerResult<String>;
async fn set_endorser(
&self,
wallet: &impl BaseWallet,
submitter_did: &Did,
request: &str,
endorser: &Did,
) -> VcxLedgerResult<String>;
async fn endorse_transaction(
&self,
wallet: &impl BaseWallet,
endorser_did: &Did,
request_json: &str,
) -> VcxLedgerResult<()>;
async fn add_attr(
&self,
wallet: &impl BaseWallet,
target_did: &Did,
attrib_json: &str,
) -> VcxLedgerResult<String>;
async fn write_did(
&self,
wallet: &impl BaseWallet,
submitter_did: &Did,
target_did: &Did,
target_vk: &Key,
role: Option<UpdateRole>,
alias: Option<String>,
) -> VcxLedgerResult<String>;
}
/// Trait for reading anoncreds-related objects from some ledger/s.
#[async_trait]
pub trait AnoncredsLedgerRead: Debug + Send + Sync {
/// Opaque additional metadata associated with retrieving a revocation registry definition.
/// Returned as part of `get_rev_reg_def_json`, and optionally passed into
/// `get_rev_status_list`. Depending on the ledger anoncreds-method, this metadata may be
/// used in the subsequent revocation status list fetch as an optimization (e.g. to save an
/// additional ledger call).
type RevocationRegistryDefinitionAdditionalMetadata: Send + Sync;
async fn get_schema(
&self,
schema_id: &SchemaId,
submitter_did: Option<&Did>,
) -> VcxLedgerResult<Schema>;
async fn get_cred_def(
&self,
cred_def_id: &CredentialDefinitionId,
submitter_did: Option<&Did>,
) -> VcxLedgerResult<CredentialDefinition>;
/// Get the anoncreds [RevocationRegistryDefinition] associated with the given ID.
/// Also returns any trait-specific additional metadata for the rev reg.
async fn get_rev_reg_def_json(
&self,
rev_reg_id: &RevocationRegistryDefinitionId,
) -> VcxLedgerResult<(
RevocationRegistryDefinition,
Self::RevocationRegistryDefinitionAdditionalMetadata,
)>;
#[deprecated(note = "use revocation status lists instead")]
async fn get_rev_reg_delta_json(
&self,
rev_reg_id: &RevocationRegistryDefinitionId,
from: Option<u64>,
to: Option<u64>,
) -> VcxLedgerResult<(RevocationRegistryDelta, u64)>;
/// Fetch the revocation status list associated with the ID at the given epoch second
/// `timestamp`. Optionally, metadata from a revocation registry definition fetch can be
/// passed in to optimize required ledger calls.
///
/// Returns the complete [RevocationStatusList] closest to (at or before) the timestamp, and
/// also returns the actual timestamp that the returned status list entry was made.
async fn get_rev_status_list(
&self,
rev_reg_id: &RevocationRegistryDefinitionId,
timestamp: u64,
rev_reg_def_meta: Option<&Self::RevocationRegistryDefinitionAdditionalMetadata>,
) -> VcxLedgerResult<(RevocationStatusList, u64)>;
async fn get_rev_reg(
&self,
rev_reg_id: &RevocationRegistryDefinitionId,
timestamp: u64,
) -> VcxLedgerResult<(RevocationRegistry, u64)>;
}
#[async_trait]
pub trait AnoncredsLedgerWrite: Debug + Send + Sync {
async fn publish_schema(
&self,
wallet: &impl BaseWallet,
schema_json: Schema,
submitter_did: &Did,
endorser_did: Option<&Did>,
) -> VcxLedgerResult<()>;
async fn publish_cred_def(
&self,
wallet: &impl BaseWallet,
cred_def_json: CredentialDefinition,
submitter_did: &Did,
) -> VcxLedgerResult<()>;
async fn publish_rev_reg_def(
&self,
wallet: &impl BaseWallet,
rev_reg_def: RevocationRegistryDefinition,
submitter_did: &Did,
) -> VcxLedgerResult<()>;
async fn publish_rev_reg_delta(
&self,
wallet: &impl BaseWallet,
rev_reg_id: &RevocationRegistryDefinitionId,
rev_reg_entry_json: RevocationRegistryDelta,
submitter_did: &Did,
) -> VcxLedgerResult<()>;
}
/// Simple utility trait to determine whether the implementor can support reading/writing
/// the specific identifier types.
pub trait AnoncredsLedgerSupport {
fn supports_schema(&self, id: &SchemaId) -> bool;
fn supports_credential_definition(&self, id: &CredentialDefinitionId) -> bool;
fn supports_revocation_registry(&self, id: &RevocationRegistryDefinitionId) -> bool;
}
pub trait TaaConfigurator: Debug + Send + Sync {
fn set_txn_author_agreement_options(
&self,
taa_options: TxnAuthrAgrmtOptions,
) -> VcxLedgerResult<()>;
fn get_txn_author_agreement_options(&self) -> VcxLedgerResult<Option<TxnAuthrAgrmtOptions>>;
}
#[derive(Clone, Serialize)]
pub struct TxnAuthrAgrmtOptions {
pub text: String,
pub version: String,
pub mechanism: String,
}
| rust | Apache-2.0 | 2d3034ed73ba8d49e0f72251b4c7cfb859a1efe7 | 2026-01-04T20:24:59.602734Z | false |
openwallet-foundation/vcx | https://github.com/openwallet-foundation/vcx/blob/2d3034ed73ba8d49e0f72251b4c7cfb859a1efe7/aries/aries_vcx_ledger/src/ledger/arc.rs | aries/aries_vcx_ledger/src/ledger/arc.rs | //! Contains convenience wrappers for the aries_vcx_ledger traits when working with [Arc]s.
use std::sync::Arc;
use anoncreds_types::data_types::{
identifiers::{
cred_def_id::CredentialDefinitionId, rev_reg_def_id::RevocationRegistryDefinitionId,
schema_id::SchemaId,
},
ledger::{
cred_def::CredentialDefinition, rev_reg::RevocationRegistry,
rev_reg_def::RevocationRegistryDefinition, rev_reg_delta::RevocationRegistryDelta,
rev_status_list::RevocationStatusList, schema::Schema,
},
};
use async_trait::async_trait;
use did_parser_nom::Did;
use super::base_ledger::{AnoncredsLedgerRead, AnoncredsLedgerSupport};
use crate::errors::error::VcxLedgerResult;
/// Trait designed to convert [Arc<T>] into [ArcLedgerTraitWrapper<T>], such that
/// [Arc<T>] can inherit any trait implementation of [ArcLedgerTraitWrapper]. (e.g.
/// [AnoncredsLedgerRead], [AnoncredsLedgerSupport]).
pub trait IntoArcLedgerTrait<T>
where
Self: Sized,
{
fn into_impl(self) -> ArcLedgerTraitWrapper<T>;
}
impl<T> IntoArcLedgerTrait<T> for Arc<T> {
fn into_impl(self) -> ArcLedgerTraitWrapper<T> {
ArcLedgerTraitWrapper(self)
}
}
/// Thin wrapper over some [Arc<T>]. Designed to implement relevant aries_vcx_ledger
/// traits on behalf of [Arc<T>], if [T] implements those traits. Necessary since [Arc<T>]
/// would not inherit those implementations automatically.
#[derive(Debug)]
pub struct ArcLedgerTraitWrapper<T>(Arc<T>);
#[async_trait]
impl<T> AnoncredsLedgerRead for ArcLedgerTraitWrapper<T>
where
T: AnoncredsLedgerRead,
{
type RevocationRegistryDefinitionAdditionalMetadata =
T::RevocationRegistryDefinitionAdditionalMetadata;
async fn get_schema(
&self,
schema_id: &SchemaId,
submitter_did: Option<&Did>,
) -> VcxLedgerResult<Schema> {
self.0.get_schema(schema_id, submitter_did).await
}
async fn get_cred_def(
&self,
cred_def_id: &CredentialDefinitionId,
submitter_did: Option<&Did>,
) -> VcxLedgerResult<CredentialDefinition> {
self.0.get_cred_def(cred_def_id, submitter_did).await
}
async fn get_rev_reg_def_json(
&self,
rev_reg_id: &RevocationRegistryDefinitionId,
) -> VcxLedgerResult<(
RevocationRegistryDefinition,
Self::RevocationRegistryDefinitionAdditionalMetadata,
)> {
self.0.get_rev_reg_def_json(rev_reg_id).await
}
async fn get_rev_reg_delta_json(
&self,
rev_reg_id: &RevocationRegistryDefinitionId,
from: Option<u64>,
to: Option<u64>,
) -> VcxLedgerResult<(RevocationRegistryDelta, u64)> {
#[allow(deprecated)]
self.0.get_rev_reg_delta_json(rev_reg_id, from, to).await
}
async fn get_rev_status_list(
&self,
rev_reg_id: &RevocationRegistryDefinitionId,
timestamp: u64,
rev_reg_def_meta: Option<&Self::RevocationRegistryDefinitionAdditionalMetadata>,
) -> VcxLedgerResult<(RevocationStatusList, u64)> {
self.0
.get_rev_status_list(rev_reg_id, timestamp, rev_reg_def_meta)
.await
}
async fn get_rev_reg(
&self,
rev_reg_id: &RevocationRegistryDefinitionId,
timestamp: u64,
) -> VcxLedgerResult<(RevocationRegistry, u64)> {
self.0.get_rev_reg(rev_reg_id, timestamp).await
}
}
impl<T> AnoncredsLedgerSupport for ArcLedgerTraitWrapper<T>
where
T: AnoncredsLedgerSupport,
{
fn supports_schema(&self, id: &SchemaId) -> bool {
self.0.supports_schema(id)
}
fn supports_credential_definition(&self, id: &CredentialDefinitionId) -> bool {
self.0.supports_credential_definition(id)
}
fn supports_revocation_registry(&self, id: &RevocationRegistryDefinitionId) -> bool {
self.0.supports_revocation_registry(id)
}
}
| rust | Apache-2.0 | 2d3034ed73ba8d49e0f72251b4c7cfb859a1efe7 | 2026-01-04T20:24:59.602734Z | false |
openwallet-foundation/vcx | https://github.com/openwallet-foundation/vcx/blob/2d3034ed73ba8d49e0f72251b4c7cfb859a1efe7/aries/aries_vcx_ledger/src/ledger/indy/mod.rs | aries/aries_vcx_ledger/src/ledger/indy/mod.rs | pub mod pool;
| rust | Apache-2.0 | 2d3034ed73ba8d49e0f72251b4c7cfb859a1efe7 | 2026-01-04T20:24:59.602734Z | false |
openwallet-foundation/vcx | https://github.com/openwallet-foundation/vcx/blob/2d3034ed73ba8d49e0f72251b4c7cfb859a1efe7/aries/aries_vcx_ledger/src/ledger/indy/pool.rs | aries/aries_vcx_ledger/src/ledger/indy/pool.rs | pub mod test_utils {
use std::{env, fs, io::Write, path::PathBuf};
pub fn get_temp_dir_path() -> PathBuf {
env::temp_dir()
}
pub fn get_temp_file_path(filename: &str) -> PathBuf {
let mut path = env::temp_dir();
path.push(filename);
path
}
pub fn get_txns_localhost(test_pool_ip: String) -> Vec<String> {
vec![
format!(
r#"{{"reqSignature":{{}},"txn":{{"data":{{"data":{{"alias":"Node1","blskey":"4N8aUNHSgjQVgkpm8nhNEfDf6txHznoYREg9kirmJrkivgL4oSEimFF6nsQ6M41QvhM2Z33nves5vfSn9n1UwNFJBYtWVnHYMATn76vLuL3zU88KyeAYcHfsih3He6UHcXDxcaecHVz6jhCYz1P2UZn2bDVruL5wXpehgBfBaLKm3Ba","blskey_pop":"RahHYiCvoNCtPTrVtP7nMC5eTYrsUA8WjXbdhNc8debh1agE9bGiJxWBXYNFbnJXoXhWFMvyqhqhRoq737YQemH5ik9oL7R4NTTCz2LEZhkgLJzB3QRQqJyBNyv7acbdHrAT8nQ9UkLbaVL9NBpnWXBTw4LEMePaSHEw66RzPNdAX1","client_ip":"{test_pool_ip}","client_port":9702,"node_ip":"{test_pool_ip}","node_port":9701,"services":["VALIDATOR"]}},"dest":"Gw6pDLhcBcoQesN72qfotTgFa7cbuqZpkX3Xo6pLhPhv"}},"metadata":{{"from":"Th7MpTaRZVRYnPiabds81Y"}},"type":"0"}},"txnMetadata":{{"seqNo":1,"txnId":"fea82e10e894419fe2bea7d96296a6d46f50f93f9eeda954ec461b2ed2950b62"}},"ver":"1"}}"#
),
format!(
r#"{{"reqSignature":{{}},"txn":{{"data":{{"data":{{"alias":"Node2","blskey":"37rAPpXVoxzKhz7d9gkUe52XuXryuLXoM6P6LbWDB7LSbG62Lsb33sfG7zqS8TK1MXwuCHj1FKNzVpsnafmqLG1vXN88rt38mNFs9TENzm4QHdBzsvCuoBnPH7rpYYDo9DZNJePaDvRvqJKByCabubJz3XXKbEeshzpz4Ma5QYpJqjk","blskey_pop":"Qr658mWZ2YC8JXGXwMDQTzuZCWF7NK9EwxphGmcBvCh6ybUuLxbG65nsX4JvD4SPNtkJ2w9ug1yLTj6fgmuDg41TgECXjLCij3RMsV8CwewBVgVN67wsA45DFWvqvLtu4rjNnE9JbdFTc1Z4WCPA3Xan44K1HoHAq9EVeaRYs8zoF5","client_ip":"{test_pool_ip}","client_port":9704,"node_ip":"{test_pool_ip}","node_port":9703,"services":["VALIDATOR"]}},"dest":"8ECVSk179mjsjKRLWiQtssMLgp6EPhWXtaYyStWPSGAb"}},"metadata":{{"from":"EbP4aYNeTHL6q385GuVpRV"}},"type":"0"}},"txnMetadata":{{"seqNo":2,"txnId":"1ac8aece2a18ced660fef8694b61aac3af08ba875ce3026a160acbc3a3af35fc"}},"ver":"1"}}"#
),
format!(
r#"{{"reqSignature":{{}},"txn":{{"data":{{"data":{{"alias":"Node3","blskey":"3WFpdbg7C5cnLYZwFZevJqhubkFALBfCBBok15GdrKMUhUjGsk3jV6QKj6MZgEubF7oqCafxNdkm7eswgA4sdKTRc82tLGzZBd6vNqU8dupzup6uYUf32KTHTPQbuUM8Yk4QFXjEf2Usu2TJcNkdgpyeUSX42u5LqdDDpNSWUK5deC5","blskey_pop":"QwDeb2CkNSx6r8QC8vGQK3GRv7Yndn84TGNijX8YXHPiagXajyfTjoR87rXUu4G4QLk2cF8NNyqWiYMus1623dELWwx57rLCFqGh7N4ZRbGDRP4fnVcaKg1BcUxQ866Ven4gw8y4N56S5HzxXNBZtLYmhGHvDtk6PFkFwCvxYrNYjh","client_ip":"{test_pool_ip}","client_port":9706,"node_ip":"{test_pool_ip}","node_port":9705,"services":["VALIDATOR"]}},"dest":"DKVxG2fXXTU8yT5N7hGEbXB3dfdAnYv1JczDUHpmDxya"}},"metadata":{{"from":"4cU41vWW82ArfxJxHkzXPG"}},"type":"0"}},"txnMetadata":{{"seqNo":3,"txnId":"7e9f355dffa78ed24668f0e0e369fd8c224076571c51e2ea8be5f26479edebe4"}},"ver":"1"}}"#
),
format!(
r#"{{"reqSignature":{{}},"txn":{{"data":{{"data":{{"alias":"Node4","blskey":"2zN3bHM1m4rLz54MJHYSwvqzPchYp8jkHswveCLAEJVcX6Mm1wHQD1SkPYMzUDTZvWvhuE6VNAkK3KxVeEmsanSmvjVkReDeBEMxeDaayjcZjFGPydyey1qxBHmTvAnBKoPydvuTAqx5f7YNNRAdeLmUi99gERUU7TD8KfAa6MpQ9bw","blskey_pop":"RPLagxaR5xdimFzwmzYnz4ZhWtYQEj8iR5ZU53T2gitPCyCHQneUn2Huc4oeLd2B2HzkGnjAff4hWTJT6C7qHYB1Mv2wU5iHHGFWkhnTX9WsEAbunJCV2qcaXScKj4tTfvdDKfLiVuU2av6hbsMztirRze7LvYBkRHV3tGwyCptsrP","client_ip":"{test_pool_ip}","client_port":9708,"node_ip":"{test_pool_ip}","node_port":9707,"services":["VALIDATOR"]}},"dest":"4PS3EDQ3dW1tci1Bp6543CfuuebjFrg36kLAUcskGfaA"}},"metadata":{{"from":"TWwCRQRZ2ZHMJFn9TzLp7W"}},"type":"0"}},"txnMetadata":{{"seqNo":4,"txnId":"aa5e817d7cc626170eca175822029339a444eb0ee8f0bd20d3b0b76e566fb008"}},"ver":"1"}}"#
),
]
}
pub fn get_txns_sovrin_testnet() -> Vec<String> {
vec![
r#"{"reqSignature":{},"txn":{"data":{"data":{"alias":"australia","client_ip":"52.64.96.160","client_port":"9702","node_ip":"52.64.96.160","node_port":"9701","services":["VALIDATOR"]},"dest":"UZH61eLH3JokEwjMWQoCMwB3PMD6zRBvG6NCv5yVwXz"},"metadata":{"from":"3U8HUen8WcgpbnEz1etnai"},"type":"0"},"txnMetadata":{"seqNo":1,"txnId":"c585f1decb986f7ff19b8d03deba346ab8a0494cc1e4d69ad9b8acb0dfbeab6f"},"ver":"1"}"#,
r#"{"reqSignature":{},"txn":{"data":{"data":{"alias":"brazil","client_ip":"54.233.203.241","client_port":"9702","node_ip":"54.233.203.241","node_port":"9701","services":["VALIDATOR"]},"dest":"2MHGDD2XpRJohQzsXu4FAANcmdypfNdpcqRbqnhkQsCq"},"metadata":{"from":"G3knUCmDrWd1FJrRryuKTw"},"type":"0"},"txnMetadata":{"seqNo":2,"txnId":"5c8f52ca28966103ff0aad98160bc8e978c9ca0285a2043a521481d11ed17506"},"ver":"1"}"#,
r#"{"reqSignature":{},"txn":{"data":{"data":{"alias":"canada","client_ip":"52.60.207.225","client_port":"9702","node_ip":"52.60.207.225","node_port":"9701","services":["VALIDATOR"]},"dest":"8NZ6tbcPN2NVvf2fVhZWqU11XModNudhbe15JSctCXab"},"metadata":{"from":"22QmMyTEAbaF4VfL7LameE"},"type":"0"},"txnMetadata":{"seqNo":3,"txnId":"408c7c5887a0f3905767754f424989b0089c14ac502d7f851d11b31ea2d1baa6"},"ver":"1"}"#,
r#"{"reqSignature":{},"txn":{"data":{"data":{"alias":"england","client_ip":"52.56.191.9","client_port":"9702","node_ip":"52.56.191.9","node_port":"9701","services":["VALIDATOR"]},"dest":"DNuLANU7f1QvW1esN3Sv9Eap9j14QuLiPeYzf28Nub4W"},"metadata":{"from":"NYh3bcUeSsJJcxBE6TTmEr"},"type":"0"},"txnMetadata":{"seqNo":4,"txnId":"d56d0ff69b62792a00a361fbf6e02e2a634a7a8da1c3e49d59e71e0f19c27875"},"ver":"1"}"#,
r#"{"reqSignature":{},"txn":{"data":{"data":{"alias":"korea","client_ip":"52.79.115.223","client_port":"9702","node_ip":"52.79.115.223","node_port":"9701","services":["VALIDATOR"]},"dest":"HCNuqUoXuK9GXGd2EULPaiMso2pJnxR6fCZpmRYbc7vM"},"metadata":{"from":"U38UHML5A1BQ1mYh7tYXeu"},"type":"0"},"txnMetadata":{"seqNo":5,"txnId":"76201e78aca720dbaf516d86d9342ad5b5d46f5badecf828eb9edfee8ab48a50"},"ver":"1"}"#,
r#"{"reqSignature":{},"txn":{"data":{"data":{"alias":"singapore","client_ip":"13.228.62.7","client_port":"9702","node_ip":"13.228.62.7","node_port":"9701","services":["VALIDATOR"]},"dest":"Dh99uW8jSNRBiRQ4JEMpGmJYvzmF35E6ibnmAAf7tbk8"},"metadata":{"from":"HfXThVwhJB4o1Q1Fjr4yrC"},"type":"0"},"txnMetadata":{"seqNo":6,"txnId":"51e2a46721d104d9148d85b617833e7745fdbd6795cb0b502a5b6ea31d33378e"},"ver":"1"}"#,
r#"{"reqSignature":{},"txn":{"data":{"data":{"alias":"virginia","client_ip":"34.225.215.131","client_port":"9702","node_ip":"34.225.215.131","node_port":"9701","services":["VALIDATOR"]},"dest":"EoGRm7eRADtHJRThMCrBXMUM2FpPRML19tNxDAG8YTP8"},"metadata":{"from":"SPdfHq6rGcySFVjDX4iyCo"},"type":"0"},"txnMetadata":{"seqNo":7,"txnId":"0a4992ea442b53e3dca861deac09a8d4987004a8483079b12861080ea4aa1b52"},"ver":"1"}"#,
r#"{"reqSignature":{"type":"ED25519","values":[{"from":"3U8HUen8WcgpbnEz1etnai","value":"NXjsBfaDijk6P6W6fg1EKrzPYhDvkNHbDcSMaYdja4URdiEdaPFcqXQttgwytcKZL79BsV3i8ShWbDS5L9Um5Pj"}]},"txn":{"data":{"data":{"alias":"australia","blskey":"31My1Ya9D1v5edgkGfYb96k4HWN1GwWWUeEnzzgw3NpiVmjpyjKgPmTYvPWZAYt8CLJLWzoQrEcBYhKRedsx8JMEB4LyPVx5vgbcjKsiUK2985t9Pkpn45UAYjDvVmGSbF2y99mMjQxpt7nCwGZ9yKcEm1cLpyHxvbnceZGkf8e9HYs"},"dest":"UZH61eLH3JokEwjMWQoCMwB3PMD6zRBvG6NCv5yVwXz"},"metadata":{"digest":"f8297516300f34624d25bf38b558f8ac9df2830a4e7fe8ccdf6816ec597da4cc","from":"3U8HUen8WcgpbnEz1etnai","reqId":1518718611795589},"type":"0"},"txnMetadata":{"seqNo":8,"txnTime":1518718611},"ver":"1"}"#,
r#"{"reqSignature":{"type":"ED25519","values":[{"from":"3U8HUen8WcgpbnEz1etnai","value":"4wiCViKevghYdtcdJXdAmS4Cwy9dAsc5eDUqHnjZXcnBbVpc71iHdyWj83U4teK65Yq2g2no8ddzJscEVTZn1ueC"}]},"txn":{"data":{"data":{"alias":"australia","blskey":"KMbkBaLigL6wUbYZmh3d41EeCRVrW1hWkpGRcy2CXZ6ugZF1Zb7ZeL3RPRasaARYkuWmjYAuLE8WiVC1dL5ZQuJczAJfDsk73hxivHxqeBaXDQwEBN2dESLZHdK3oMU79ZhqBqnEgvvAvmVyyneW661if5c45AFJgGYPtpenxS49MB"},"dest":"UZH61eLH3JokEwjMWQoCMwB3PMD6zRBvG6NCv5yVwXz"},"metadata":{"digest":"77ab856e84ef72f87a6e99ecd447da338d1eddf332b9cd33a1399aba98d39ef4","from":"3U8HUen8WcgpbnEz1etnai","reqId":1518718754041702},"type":"0"},"txnMetadata":{"seqNo":9,"txnTime":1518718754},"ver":"1"}"#,
r#"{"reqSignature":{"type":"ED25519","values":[{"from":"G3knUCmDrWd1FJrRryuKTw","value":"5owgEB8jgYUaGsH3pV6DyFMSiwXPqMgM4u9NzgCyJpnENTzyF1BmeVaNomRunbL9R4EhfbrDNHW9RJFd5GT5pAPs"}]},"txn":{"data":{"data":{"alias":"brazil","blskey":"2G1tp8pjdRSiZnpsWpN5c4tnGGTCPbqEkf8MyaVnfSxBun7pdtRqq83E7XnY4uzNmzpBF5PZcPBonfZXzCT2qWjRAB7PaDUWU5zWfLKhNoRmEzaeFp2dVkd9XrcefSfynStWsiPmv4tG8CHX153kL9Le7LMBk9qCRjeXn77wCUXqyvB"},"dest":"2MHGDD2XpRJohQzsXu4FAANcmdypfNdpcqRbqnhkQsCq"},"metadata":{"digest":"999bb3eecd2807ebf31c619518775f6219a1a6e51234f3a1f3b1021dd900dd97","from":"G3knUCmDrWd1FJrRryuKTw","reqId":1518719363728031},"type":"0"},"txnMetadata":{"seqNo":10,"txnTime":1518719363},"ver":"1"}"#,
r#"{"reqSignature":{"type":"ED25519","values":[{"from":"22QmMyTEAbaF4VfL7LameE","value":"5yVCBN5z8ehtM14FdGcRPDEc3asUrEH83PdbEBpfyrvHprn8iUZMBSCo4kkirvS1HirLLxU4mHssGvm4baGfTXfc"}]},"txn":{"data":{"data":{"alias":"canada","blskey":"q6nBf5jDDQN23yKEvVsxYjMkS843yspF44867S9Fhht2uUogbAed4cXLfxdTJMLYvsNT2fhA2jmnNSQwUyWfXjBFUSZqNhvJdC3d5XvcW8aqCGnV1BY9fR1kvrQXoLjaYgr1Je33NJxLNpJLumGF6WvuW6SuZYJPbfWxo7F1Vhy8oV"},"dest":"8NZ6tbcPN2NVvf2fVhZWqU11XModNudhbe15JSctCXab"},"metadata":{"digest":"306bb20ca4c46e485e0c93abd6ee9960d8954928d5603d79ade75c7ef22c4288","from":"22QmMyTEAbaF4VfL7LameE","reqId":1518719479176817},"type":"0"},"txnMetadata":{"seqNo":11,"txnTime":1518719479},"ver":"1"}"#,
r#"{"reqSignature":{"type":"ED25519","values":[{"from":"NYh3bcUeSsJJcxBE6TTmEr","value":"G99xrEafV1BhUtgLb8jugDQvu4JLp5R2s5T4ZqSuy5pPNnDRZyhWn6iW89Uwe476uxxdugx7TzEXY61wZXCsUNs"}]},"txn":{"data":{"data":{"alias":"england","blskey":"3TXrLKV5Yn2BE47NBEvM9u6J2DUsn414sUhQQQN1X2mRKhsPvWnixqo1AbFC5kRVjpHDhRPzvenm7cApfGcCGMDME1mSwESxiYgkgpahc9DuGD5hvFieryk3yJ96jcumWA7NUUDYmiHhZfCThXvGS9agXK4Kt3sgxBYQ17yN7wj3cRN"},"dest":"DNuLANU7f1QvW1esN3Sv9Eap9j14QuLiPeYzf28Nub4W"},"metadata":{"digest":"fb5062d61960bd6f742519c6df9ca5463e6c83689cad58a7c84783a7d013c3fb","from":"NYh3bcUeSsJJcxBE6TTmEr","reqId":1518719555172082},"type":"0"},"txnMetadata":{"seqNo":12,"txnTime":1518719555},"ver":"1"}"#,
r#"{"reqSignature":{"type":"ED25519","values":[{"from":"U38UHML5A1BQ1mYh7tYXeu","value":"4ns8r24bUMZqs2AVrBUpK66gGBA3pp2h98BM8XC2nHghbyrmWA6KpSjnmEfLKBgDZcFaoSX4Wu2d6TJzeRsVQQ8Q"}]},"txn":{"data":{"data":{"alias":"korea","blskey":"2b51xiHs4afNBiTUenKJ2XHmPMfYcNFHAwB2x39z953y1YawDTKnUW9Q2gPCQvRR5esvF235PHfv9b5GYFnXPo41wzotm7LiYsYimAarVh2PFo3CAz5DSo9xA6Xo9EhP2JnDSvi2APqGn2UpoYtpRtz2bMFurqrnw6UPz4vq91x23hJ"},"dest":"HCNuqUoXuK9GXGd2EULPaiMso2pJnxR6fCZpmRYbc7vM"},"metadata":{"digest":"4943fc79d796067841ad0aeb0e44c54bb88a1e152e2bc482925ebe3df9e5d032","from":"U38UHML5A1BQ1mYh7tYXeu","reqId":1518719649363976},"type":"0"},"txnMetadata":{"seqNo":13,"txnTime":1518719649},"ver":"1"}"#,
r#"{"reqSignature":{"type":"ED25519","values":[{"from":"HfXThVwhJB4o1Q1Fjr4yrC","value":"2pC8hkN3MxyJeUZmkqhvvUEi3uCwTbKd14Yjc4uVJjNqx2Hj6oXvwaZPvmJn3VJMkKKE7tpFrtwyFXx8CJ5WwArf"}]},"txn":{"data":{"data":{"alias":"singapore","blskey":"CT7HsX8MAcAnWZ8CFF1ttdYG91hNc7K9dGfpcp4QprLRYVR2XSr2ywHuNT5zLPvTkGDjrjyF2HdMbLkdNGgRa5LH1Am3D619yycJjP8t51c2XygEjoa6J1TmUjYkuC44Q6Aq1BriX5hJ2oxJL3bvnM2g7QRzRPyFdM771zNutV72W3"},"dest":"Dh99uW8jSNRBiRQ4JEMpGmJYvzmF35E6ibnmAAf7tbk8"},"metadata":{"digest":"2dce61e98838e65cd7c303adc248c8fabeab4ecc0492f16572521b2f1939c975","from":"HfXThVwhJB4o1Q1Fjr4yrC","reqId":1518719769599617},"type":"0"},"txnMetadata":{"seqNo":14,"txnTime":1518719769},"ver":"1"}"#,
r#"{"reqSignature":{"type":"ED25519","values":[{"from":"SPdfHq6rGcySFVjDX4iyCo","value":"2xLQwrn2jvg6XZcXGuW6AQ3PKiSHPNAdaHM6CVb8iwDA15HHoPUSi2PGkFvUyFya82QiCA22Y11NDX4Yh4Kx7DqR"}]},"txn":{"data":{"data":{"alias":"virginia","blskey":"372y1y4t9JdTtkyA4C5ANi88YGGaBtSpWd1FL6TJawxn1gnkebpztpsiN5AjTkwARMsTZWX8VyBZ3UGhPd7grmVgoBogTBf1LyvpnmVJR2p9TC26fDFz9GFhynAcPfHQ3xLvVjSyAYH8JjEHRS2yMXxhq8gZCTy494shNXP1wKCD8Ny"},"dest":"EoGRm7eRADtHJRThMCrBXMUM2FpPRML19tNxDAG8YTP8"},"metadata":{"digest":"113c1a81394cbadc48d57aef9d9eb93722f318d01261ed3dc162d8e0f527e37a","from":"SPdfHq6rGcySFVjDX4iyCo","reqId":1518719862981841},"type":"0"},"txnMetadata":{"seqNo":15,"txnTime":1518719863},"ver":"1"}"#,
r#"{"reqSignature":{"type":"ED25519","values":[{"from":"A3h7JbvErKPCfaJx3VNRJ9","value":"4jzEdvJYAKB4vMNMU2VVe4dvGwT2fy28WPuvZipVEqf6R7qkuDWBXLYLBSzGAkUErtRKUnb7KH2eSrZSEgHRozTx"}]},"txn":{"data":{"data":{"alias":"ibm","blskey":"Wv1XfnPWngRPQNQnnaMsewidNtc6Rc2mx842q5ApKTgUdUs2YBZZFgSw4TdWa8HVMZvptiukdooXhTimEwxw9dFQRK5faYb2LBdeRZ6RR2kXz39a6vjyG71arL7Q6FnetH6N2NMFBACdu1PBUYKWAyBn5K8ZUUGgt2YhmZJ9DnieLa","client_ip":"169.60.5.114","client_port":9702,"node_ip":"169.60.5.114","node_port":9701,"services":["VALIDATOR"]},"dest":"Eq7m7GMFKPeq5Ek3HH1PkHxzZ46R9VL1Eube3U9wfjp5"},"metadata":{"digest":"a1dfd555da4085210b53245a199a7d431f4a6328e8936050ec3dc794fe5a2b07","from":"A3h7JbvErKPCfaJx3VNRJ9","reqId":1518798036389445},"type":"0"},"txnMetadata":{"seqNo":16,"txnTime":1518798036},"ver":"1"}"#,
r#"{"reqSignature":{"type":"ED25519","values":[{"from":"TnxHS11bsfWrzzi612R2X8","value":"5tHfCPQfV2XAqo7V42akRqmtDqmbX4HUMAZSy9xKz6vERMSDFHmraW4ZEK9hUacjiRthn7P5KuLmopu1mCLwWXhq"}]},"txn":{"data":{"data":{"alias":"RFCU","blskey":"3FuY8wqmBi2XxL4EtJDo3Lhad48QN5ZbhH4kEV3Kfkeb53x94qmWfRndZQJo91M3aWtYpZaZqDaqrQMpuEcAvh8g9hLmb9BWbhK6BVvACSJ2RUiDhBRp4NPkg93tNmQjkdzWoUznFZvbPTTBPBcsmngTake7Sm4YLf1tbd8vuF7Nqkd","client_ip":"207.108.62.234","client_port":9702,"node_ip":"207.108.62.234","node_port":9701,"services":["VALIDATOR"]},"dest":"2B8bkZX3SvcBq3amP7aeATsSPz82RyyCJQbEjZpLgZLh"},"metadata":{"digest":"54d0fb8b9ebc2167d16f9d2027b49917fb484ec6e33caad48bf1516ba27460af","from":"TnxHS11bsfWrzzi612R2X8","reqId":1518798718080714},"type":"0"},"txnMetadata":{"seqNo":17,"txnTime":1518798718},"ver":"1"}"#,
r#"{"reqSignature":{"type":"ED25519","values":[{"from":"ApndPYajjcdTnpvopThGwh","value":"5eyGhLmKmJx5SzkqmS5LD4s4rkQHDAeGh7PmZKhTNJ8MxdbSaZEGjVj4XYD37GeGTepfLwmivJDJjfYaDQGV7aoi"}]},"txn":{"data":{"data":{"alias":"pcValidator01","blskey":"3NU2sWYG7eeJY66W1FGpLgLaDS9fDQfKMNgPGMCk9iTcatMd4XdmAF5UqULkLUpGWABftNTrRsgm82DpfJ1cTu7CTB84KYoW4SYf7Rq4a2wi6rVbmU6k76ZYgmny6h8vqBbdRwozxVTjkPyzV6Z5MSA3vrDdf31iiiPEcXTTT3oFhKC","client_ip":"52.175.254.49","client_port":9799,"node_ip":"52.175.254.49","node_port":9701,"services":["VALIDATOR"]},"dest":"5fKwygs8KEGoUPGa65qz1oCm7h6Fb7HrML9r4jmZ9cic"},"metadata":{"digest":"9dd9cd0dc1ee21694c798c41e80922afd44e70b4e067b2c9c3582c929248ee74","from":"ApndPYajjcdTnpvopThGwh","reqId":1518809271040696},"type":"0"},"txnMetadata":{"seqNo":18,"txnTime":1518809270},"ver":"1"}"#,
r#"{"reqSignature":{"type":"ED25519","values":[{"from":"G4zXq8L7L8n73WKSVv2HxY","value":"Yyd84xQCFWTQovZjUFohaXp3UhXdHX4wj25CGnpvcQs9LKE37DRj4DWvh2RkJALeBLtPZJsXwzKyuivPxLA8QVj"}]},"txn":{"data":{"data":{"alias":"NewtonD","blskey":"36fw9Bz4tLCkzZhUQdA2N51AZWCF6sdyiDuAX7WuNsqeq3C2dCzvS9GeSxt9t1BWxtHWc2GJDVBcqZKGh7Tg2eoQa1KTPhPFRdShBhYPDfP85gKKshHa5aEdLBvTsUkADaDoyFv4rhqTLDFbdcu4WsQE59pxyj3QTSAURgRhxkcm2oJ","client_ip":"52.165.40.82","client_port":9701,"node_ip":"40.69.165.222","node_port":9777,"services":["VALIDATOR"]},"dest":"HU8AkmtsqvcfEtvdWAZgZZFfvKYH8vu2YdgkkHrmNDGP"},"metadata":{"digest":"e0afed7d71f511362c2b21cb90c0b68fc1cb176e233d147a267375350133a6b6","from":"G4zXq8L7L8n73WKSVv2HxY","reqId":1519949508036643},"type":"0"},"txnMetadata":{"seqNo":19,"txnTime":1519949508},"ver":"1"}"#,
r#"{"reqSignature":{"type":"ED25519","values":[{"from":"EKvw1VdXwS2pWKLLyBLCDs","value":"DqCfNstgx5q8gaM57b6qUooHCuhFFqqs7H995UDSBARoD7LWn6gaqJAmcz56NMUmtiWSqpqreBFxwPMr66xPj2Z"}]},"txn":{"data":{"data":{"alias":"Aalto","blskey":"emFqQUM4yqEWdhbk8KzLry6okMk5MsQUoR922BdBS8KBFxNAofPPDzDSR6pwu8ytZVVrfWGbVBs3D6WDt8dZAQY1xYJoAax7pt9Bkgen5Tc2BM5dLhuHpDwRLAmXFFxQbTxArAKidQeeB9wBJbScbbVnWjNNiYPreaZjgFXUGoWjSS","client_ip":"130.233.224.231","client_port":9702,"node_ip":"130.233.224.231","node_port":9701,"services":["VALIDATOR"]},"dest":"7JYQmTE6mBxa5RAZwXAj4bxqetAy64tcEUShqzJjLRrE"},"metadata":{"digest":"5c717908d4b75e92767cca818ac7530789c765c08207eec38cd18eff93b76502","from":"EKvw1VdXwS2pWKLLyBLCDs","reqId":1520418048198552},"type":"0"},"txnMetadata":{"seqNo":20,"txnTime":1520418048},"ver":"1"}"#,
r#"{"reqSignature":{"type":"ED25519","values":[{"from":"Qm7Ugni6jFRpfbPkzhXzXH","value":"jAGG7yFmyLXRGUS2yqoNikvCGWhWeS9eFRyb5vfzu9ZjuAqbiyL4SfNv8NpMAs9Bsda5Y9kZfg9wrW8GufX8NNN"}]},"txn":{"data":{"data":{"alias":"Stuard","blskey":"4Yry2Z17vf1Hf24HvRrduj3Zi5LBJ1x7PbDqNWX19RxHcYJVjpy2f9qriZk7Fx812Xip6LEhsEXWRB1qKujBwdLNbCvMFYnJK2kS2B9HNgDgbVwDbpw16QNuJMtUnvQv1B6vCmci96gypYWMvZmJ6p9qsPXA7CZ2ZSjRuLg3RqvD7y4","client_ip":"10.0.0.10","client_port":9702,"node_ip":"10.0.0.10","node_port":9701,"services":["VALIDATOR"]},"dest":"C4e4rEwPZ4bM341VEL9ysnAgBiMW42RH3UmbriPuzoCb"},"metadata":{"digest":"70d1ed111dd5fec2e46378152f0e8ed5a99728e06288f721fad337b8ba9bae3c","from":"Qm7Ugni6jFRpfbPkzhXzXH","reqId":1521022519350930},"type":"0"},"txnMetadata":{"seqNo":21,"txnTime":1521022519},"ver":"1"}"#,
r#"{"reqSignature":{"type":"ED25519","values":[{"from":"Qm7Ugni6jFRpfbPkzhXzXH","value":"5yKYfGouHn494CtFhEMLYYuWHC9rPhsUWBpXLneJT8jt869rjVxeab9iABYS2Uq55Avjwtd25Xfvyru57HwQMfZb"}]},"txn":{"data":{"data":{"alias":"Stuard","blskey":"4Yry2Z17vf1Hf24HvRrduj3Zi5LBJ1x7PbDqNWX19RxHcYJVjpy2f9qriZk7Fx812Xip6LEhsEXWRB1qKujBwdLNbCvMFYnJK2kS2B9HNgDgbVwDbpw16QNuJMtUnvQv1B6vCmci96gypYWMvZmJ6p9qsPXA7CZ2ZSjRuLg3RqvD7y4","client_ip":"185.27.183.66","client_port":9702,"node_ip":"185.27.183.66","node_port":9701,"services":["VALIDATOR"]},"dest":"C4e4rEwPZ4bM341VEL9ysnAgBiMW42RH3UmbriPuzoCb"},"metadata":{"digest":"0c7f5c756b286dcf1c769cec7a3d5cfeaf57c38ac25e4a83e9d37b417b20774c","from":"Qm7Ugni6jFRpfbPkzhXzXH","reqId":1521070797707610},"type":"0"},"txnMetadata":{"seqNo":22,"txnTime":1521070797},"ver":"1"}"#,
r#"{"reqSignature":{"type":"ED25519","values":[{"from":"FzUUYiVKCDnSWd77NHfhpZ","value":"3Q3ijuEPihRyGsZFvmb414AWWQ7iMskCHoP7bC14FgPesNdPNY3pdfddEfPf5FrCg4wzdvdAFjKaBunHHwXCG4V3"}]},"txn":{"data":{"data":{"alias":"TNO","blskey":"37d7DmcwGWM7yfnpwLGzwVy6zZwoc6cAgeeSJFBWbVh6jq5tP8dPf7s2XDxxtWafmr1JdyzycBcNztEsE8Uf9qX2jRoXzhCnjEEYJCAByEn5hWC2VQ9EqkuKzq28Vob7Piof7rEJeUPxuBZtrXL1khyTN2waQtix6CYtv9QejNPZVJ2","client_ip":"134.221.127.143","client_port":9702,"node_ip":"134.221.127.143","node_port":9701,"services":["VALIDATOR"]},"dest":"TZxmZoXwNk1X5o48pXqbDFz6mTJT5QkiRme9z5p86KQ"},"metadata":{"digest":"0f3b44855c6f562b17321efe51f00edab1cdbe8608c667669e8085430fa32cc5","from":"FzUUYiVKCDnSWd77NHfhpZ","reqId":1521195244613677},"type":"0"},"txnMetadata":{"seqNo":23,"txnTime":1521195244},"ver":"1"}"#,
r#"{"reqSignature":{"type":"ED25519","values":[{"from":"6feBTywcmJUriqqnGc1zSJ","value":"3jN1g2dAPKx5giEKnc5k9GiYHBw5yFZD8D8GiuFBL7wuHUDabobCeCCDezboxqkCpHSLsVE5hDzq6RQWUKwHXwv1"}]},"txn":{"data":{"data":{"alias":"Stuard","services":[]},"dest":"C4e4rEwPZ4bM341VEL9ysnAgBiMW42RH3UmbriPuzoCb"},"metadata":{"digest":"f24b5dda0fe64addafbbdd67aa2be5731064d6c6215d56e883e67009df0ce0d8","from":"6feBTywcmJUriqqnGc1zSJ","reqId":1521760233710703},"type":"0"},"txnMetadata":{"seqNo":24,"txnTime":1521761250},"ver":"1"}"#,
r#"{"reqSignature":{"type":"ED25519","values":[{"from":"6feBTywcmJUriqqnGc1zSJ","value":"5omTkQAe1LmYQfY4PdYf3YEjVM1jBs2Qr8x8LAhghD3ymeudEvm1dyk3nQtEtNzFvAeGhnajWMA862DWM4Hg51vv"}]},"txn":{"data":{"data":{"alias":"Aalto","services":[]},"dest":"7JYQmTE6mBxa5RAZwXAj4bxqetAy64tcEUShqzJjLRrE"},"metadata":{"digest":"f526af4c7569c941f69f1fb2dc3ad6ef98bdef2aa2aceca33d43dc92900d65bb","from":"6feBTywcmJUriqqnGc1zSJ","reqId":1521822633807532},"type":"0"},"txnMetadata":{"seqNo":25,"txnTime":1521822633},"ver":"1"}"#,
r#"{"reqSignature":{"type":"ED25519","values":[{"from":"6feBTywcmJUriqqnGc1zSJ","value":"4YtbkvnTMfMA6d9FjkjBcueFGq5PnLoHFKn8HAGiLKxcob2QM6KsdwLRapQcbtn9N33NimyeFzrHCerzAcbS8fVq"}]},"txn":{"data":{"data":{"alias":"pcValidator01","services":[]},"dest":"5fKwygs8KEGoUPGa65qz1oCm7h6Fb7HrML9r4jmZ9cic"},"metadata":{"digest":"f0986bab87b08031cfaeb58a06e27e8c1214f4c20af0e26c709c1c3970c0b241","from":"6feBTywcmJUriqqnGc1zSJ","reqId":1521825598199425},"type":"0"},"txnMetadata":{"seqNo":26,"txnTime":1521825598},"ver":"1"}"#,
r#"{"reqSignature":{"type":"ED25519","values":[{"from":"G4zXq8L7L8n73WKSVv2HxY","value":"5kkkxWBUmYYcrFSKQcgaAEhcsiwJft74Js5VpwBzL1ssfFJRJgDdjhW27hZRCao994DW5b17Xgw6UqSyBLP7UmyD"}]},"txn":{"data":{"data":{"alias":"NewtonD","services":[]},"dest":"HU8AkmtsqvcfEtvdWAZgZZFfvKYH8vu2YdgkkHrmNDGP"},"metadata":{"digest":"e2d73bb8154e3372fa0c8d57c1383c2b4710308198a76580f15ce2c3ffd5f204","from":"G4zXq8L7L8n73WKSVv2HxY","reqId":1521831913747645},"type":"0"},"txnMetadata":{"seqNo":27,"txnTime":1521831913},"ver":"1"}"#,
r#"{"reqSignature":{"type":"ED25519","values":[{"from":"G4zXq8L7L8n73WKSVv2HxY","value":"4L9AFEy3gdV1KNHsuG4gWSuETzTmJ2aD5TzSdWiQCm13o6GfNAY8YoemyiTiwnX8mzxdghgc38CLhEBm3DwfC3Dv"}]},"txn":{"data":{"data":{"alias":"NewtonD","services":["VALIDATOR"]},"dest":"HU8AkmtsqvcfEtvdWAZgZZFfvKYH8vu2YdgkkHrmNDGP"},"metadata":{"digest":"d83f3622a59d8fe15448389a185752add786de3eaf0cabfc17cea86dc503c2a5","from":"G4zXq8L7L8n73WKSVv2HxY","reqId":1521833231516195},"type":"0"},"txnMetadata":{"seqNo":28,"txnTime":1521833231},"ver":"1"}"#,
r#"{"reqSignature":{"type":"ED25519","values":[{"from":"6feBTywcmJUriqqnGc1zSJ","value":"xzjjfKfJJJeQxZb5WhMYyHDcDG5dZCAvsYmBh6FtP9J1ckQUazaJ7AC2ksHzjARW9kkcFBS4B1M4R7y5Bc3BN5S"}]},"txn":{"data":{"data":{"alias":"TNO","services":[]},"dest":"TZxmZoXwNk1X5o48pXqbDFz6mTJT5QkiRme9z5p86KQ"},"metadata":{"digest":"03c5763b3be5b2c53be3f2af041071bdb2f2aa08754adbdcebbcbbe055036cd6","from":"6feBTywcmJUriqqnGc1zSJ","reqId":1522073964061797},"type":"0"},"txnMetadata":{"seqNo":29,"txnTime":1522073964},"ver":"1"}"#,
r#"{"reqSignature":{"type":"ED25519","values":[{"from":"6feBTywcmJUriqqnGc1zSJ","value":"nm4hZxHEb86rDjHddyuFgnuy7hS7bf1Biifnje3c75Kgn1eQ5frc9xwVWFUzZNFntfVckXQK3U97wRiiP7MrijK"}]},"txn":{"data":{"data":{"alias":"NewtonD","services":[]},"dest":"HU8AkmtsqvcfEtvdWAZgZZFfvKYH8vu2YdgkkHrmNDGP"},"metadata":{"digest":"a81744dd61919ea58d75904a8d6921be18362cecb174e3d5f318384c99d912c2","from":"6feBTywcmJUriqqnGc1zSJ","reqId":1523554207793968},"type":"0"},"txnMetadata":{"seqNo":30,"txnTime":1523554207},"ver":"1"}"#,
r#"{"reqSignature":{"type":"ED25519","values":[{"from":"LKjUWXR3QpGsMkgB2XFyzt","value":"671v9pVTeRwN4XybdY5tjGyJZCNhGPFq3bcBxymCGJ18EQbBdDa6LXGh3brvWQ53yncspYbywrgC7eGknnqYR2GB"}]},"txn":{"data":{"data":{"alias":"VeridiumIDC","blskey":"2HhwAzNXb6qrptphzJKiAYqGtE6dNNcK8Q33EJU8hNnAhvjC4X1Bk65MbgvPMpn4rP9HZAH78StG12HfU6VyLd6JBbp6gkgwvtXUK1QefTEGcRipj3XnVJ7tjU8KzxWqaZQW5exJQQQhmedCKZphKvvnb2wuVcoBVS3Ad3ZLm2d4apo","client_ip":"18.197.183.58","client_port":9702,"node_ip":"18.197.183.58","node_port":9701,"services":["VALIDATOR"]},"dest":"58uCeMaEiMHSi8MdEdcgVbpmzMKmiLSYCEz1vxPGJND6"},"metadata":{"digest":"64a71eb01fc9becdbea811aa449d9a588c22b47e7d7434b4dae437bf8153303f","from":"LKjUWXR3QpGsMkgB2XFyzt","reqId":1524737343827561},"type":"0"},"txnMetadata":{"seqNo":31,"txnTime":1524737343},"ver":"1"}"#,
r#"{"reqSignature":{"type":"ED25519","values":[{"from":"RtMtkBrkHCEDtGXXqRfGoV","value":"3ontWhK6hYCpGx8DgirvihSqDarZUTQ3NacwtC4okP2BNpF1xp6tzjnx6iigt8kgaRSGPacXL93AHVXeS6fvQ41t"}]},"txn":{"data":{"data":{"alias":"oregon","blskey":"2bQaqiLhyAEJh6t1xhC3jKk5PRc7v8AsEH9dxSjgVvBqwrmoiDKfSmJKBXA9kCT1uQkpaGeYyP4bkb3RA1ABYebqcswkjdVUGRZYqyxasdBD2phUbNm6WNaGtyRkhJ265KZ7YP8QaDS3NCwTXT7b8vMNmaTL8Kd1Buvaq7gS3ZLJXU6","client_ip":"18.236.138.206","client_port":9702,"node_ip":"18.236.138.206","node_port":9701,"services":["VALIDATOR"]},"dest":"4wdqCSyPeiqCbQhjsbP9Xjasm7vuU7ithawkpuoBXCBM"},"metadata":{"digest":"add1f55e950e2411deecd700285802fd154fc68668e2020df9e97cad47d79491","from":"RtMtkBrkHCEDtGXXqRfGoV","reqId":1524852414943816},"type":"0"},"txnMetadata":{"seqNo":32,"txnTime":1524852415},"ver":"1"}"#,
r#"{"reqSignature":{"type":"ED25519","values":[{"from":"2XCnRcUZJH2JEzotFHTqin","value":"5g4zsXjPumLMTVb8rCYoALeERtgue7qq6uda1vxA2wywZc5VDLBmrJbguwMztdXLCJQKg3qbu8bcYdJUERNdX1Bq"}]},"txn":{"data":{"data":{"alias":"findentity","blskey":"4jBpQMFjEabdTHArLHAbidwcaR5o7p4fAuYbfxrtypZtDbsDACj5mZRFVvkXy5F84g7ni6yNMfL5JV1E3qXYsg3fw33Jd3MTRyAGrZZmN3zNEq6WDNT8XQsaDasDUebJaTEmRWVKMZc8BbeipCPBjym2NvfAQyib1ywZZ5B8d7m5XXH","client_ip":"172.31.28.111","client_port":9799,"node_ip":"172.31.46.137","node_port":9700,"services":["VALIDATOR"]},"dest":"5bQhBNkoFKCFAtCxe1vcXBoq6FsnJ3nWKYwUfyVS3129"},"metadata":{"digest":"dcdd47c5bcffd8aeee8b281ed78b57eef5e3ba617f905885c0c7b356f07ab00a","from":"2XCnRcUZJH2JEzotFHTqin","reqId":1525741289118866},"type":"0"},"txnMetadata":{"seqNo":33,"txnTime":1525741289},"ver":"1"}"#,
r#"{"reqSignature":{"type":"ED25519","values":[{"from":"2XCnRcUZJH2JEzotFHTqin","value":"4wTCrfhT5wzBLpEkadt2UP21kPxiPJPWoKUKs3VSGAsi2427aJbTzPMFokSpPukfEHqMikGCeXP95kPZ5eRKazBy"}]},"txn":{"data":{"data":{"alias":"findentity","blskey":"4jBpQMFjEabdTHArLHAbidwcaR5o7p4fAuYbfxrtypZtDbsDACj5mZRFVvkXy5F84g7ni6yNMfL5JV1E3qXYsg3fw33Jd3MTRyAGrZZmN3zNEq6WDNT8XQsaDasDUebJaTEmRWVKMZc8BbeipCPBjym2NvfAQyib1ywZZ5B8d7m5XXH","client_ip":"34.211.203.16","client_port":9799,"node_ip":"34.218.164.50","node_port":9700,"services":["VALIDATOR"]},"dest":"5bQhBNkoFKCFAtCxe1vcXBoq6FsnJ3nWKYwUfyVS3129"},"metadata":{"digest":"0581a913d81b117dc6f5eb67e6faf734f838a9d6dd2f2a550edb620940ed522c","from":"2XCnRcUZJH2JEzotFHTqin","reqId":1525799946176362},"type":"0"},"txnMetadata":{"seqNo":34,"txnTime":1525799946},"ver":"1"}"#,
r#"{"reqSignature":{"type":"ED25519","values":[{"from":"RtMtkBrkHCEDtGXXqRfGoV","value":"2EQyW1W3EVq9Qkr6Dnk1baDeE8vPcDxgPoZdKkxnKYWLdi27NLvzjziUZ2Ckeuw4MqhDdBeafW36DMQo4fDzkjBT"}]},"txn":{"data":{"data":{"alias":"oregon","services":[]},"dest":"4wdqCSyPeiqCbQhjsbP9Xjasm7vuU7ithawkpuoBXCBM"},"metadata":{"digest":"cb346aa8a0234819aa63b5c63cf7928fbbc171f1b3c00e345c24fa3f4f1e9636","from":"RtMtkBrkHCEDtGXXqRfGoV","reqId":1526508235374190101},"type":"0"},"txnMetadata":{"seqNo":35,"txnTime":1526508235},"ver":"1"}"#,
r#"{"reqSignature":{"type":"ED25519","values":[{"from":"YHTFcv8P93i35osabNm99n","value":"2X7YznzieZ1Kc6nzWawdQHG5Z8jV8vNiwHq5BBLn8rY6SGXQCSZhichDp5V7n9he64BKoYxU6YLHuNM2DLSsEvmG"}]},"txn":{"data":{"data":{"alias":"amihan-sovrin","blskey":"14Kn3VBKja9pDCUgoVpMzf4c9rXJpvDsaHrnXkB9WtvNMHPihinjiXUNNuKdVuYiai3iTDe7mjH5o2UjfoKyApdjEgGCKqgDKpH6uzH4ZcUekR5pfe4wC172X5tiBQFScm8Ti1VmqTnUdfvGi4rV4NpBGytPMkZE1qhL1WSDCoi8riW","client_ip":"35.187.226.254","client_port":9702,"node_ip":"35.197.150.130","node_port":9701,"services":["VALIDATOR"]},"dest":"2FZAgVmRC87ZbJXSh6seFi6n7AMfBo9HaCh8HseHi37U"},"metadata":{"digest":"2986a38eaa64cee8ebfa7e5184bc98949a57555bef663ab125f83603371d6591","from":"YHTFcv8P93i35osabNm99n","reqId":1528165772663287},"type":"0"},"txnMetadata":{"seqNo":36,"txnTime":1528165772},"ver":"1"}"#,
r#"{"reqSignature":{"type":"ED25519","values":[{"from":"6feBTywcmJUriqqnGc1zSJ","value":"5kJFNauix1UPNtii8g8ahpfmEyJaoAPnFXdeSpJ9Ge3GaaLhWM3Hmr9N8ACdf6Wrs8Yg1pkXLRwmBTuDSvJDe3A"}]},"txn":{"data":{"data":{"alias":"ibm","services":[]},"dest":"Eq7m7GMFKPeq5Ek3HH1PkHxzZ46R9VL1Eube3U9wfjp5"},"metadata":{"digest":"ecd93c53a03d0da0e011973c7c4312e4b5426390930247aa48aca2b70550c2be","from":"6feBTywcmJUriqqnGc1zSJ","reqId":1528236888174137},"type":"0"},"txnMetadata":{"seqNo":37,"txnTime":1528236888},"ver":"1"}"#,
r#"{"reqSignature":{"type":"ED25519","values":[{"from":"PRCWCTWYwGJB7rczzTqBBB","value":"5nJ3vmmFxC1qHjvSWFHLvhqyRtEmxo4Z2SMpuS2U5snEShd1ZMP22eDyd1nDgPJUHRAMuYM519eMoLw4Kj4CqZgf"}]},"txn":{"data":{"data":{"alias":"valNode01","blskey":"24cgjd77KER8uzhxb1c3DbecvrSMQd3nYxBjaJTqLkgBPuAizzoFdXQkdb8LNjgnP27hTHCpLSuatQSE2YYexNXqZDtAUqPMNfsZwAU151kYFfCc6ZWLRzsm4irf4PrS5ZpnSmhT3Ta4c3m12zoTmu3FDxUkJwEBC3ubdNdA8EHcVDz","client_ip":"52.43.138.62","client_port":9702,"node_ip":"52.43.138.62","node_port":9701,"services":["VALIDATOR"]},"dest":"AYQcyJvowniMsxU9P93yzyAPCFUxg7hm1xsXitFoBr6z"},"metadata":{"digest":"5b05dceab82e7288a1003793f0b4ff642284a021b3c5746b5d799b116068428e","from":"PRCWCTWYwGJB7rczzTqBBB","reqId":1528316277953334},"type":"0"},"txnMetadata":{"seqNo":38,"txnTime":1528316278},"ver":"1"}"#,
r#"{"reqSignature":{"type":"ED25519","values":[{"from":"PRCWCTWYwGJB7rczzTqBBB","value":"4FHNA9VCJHMNUssRyaQYFsn6SVQdSddSg2BxRDFp1aurDAMY4o925WCGmoYLeNwMkf34w6nF5NrNHVhXSmPBZUs3"}]},"txn":{"data":{"data":{"alias":"valNode01","blskey":"24cgjd77KER8uzhxb1c3DbecvrSMQd3nYxBjaJTqLkgBPuAizzoFdXQkdb8LNjgnP27hTHCpLSuatQSE2YYexNXqZDtAUqPMNfsZwAU151kYFfCc6ZWLRzsm4irf4PrS5ZpnSmhT3Ta4c3m12zoTmu3FDxUkJwEBC3ubdNdA8EHcVDz","client_ip":"54.214.176.123","client_port":9702,"node_ip":"54.214.176.123","node_port":9701,"services":["VALIDATOR"]},"dest":"AYQcyJvowniMsxU9P93yzyAPCFUxg7hm1xsXitFoBr6z"},"metadata":{"digest":"b2a209bb10c902c01167e24e7f876ea2359356d43772f37cddefe42f5adf8c58","from":"PRCWCTWYwGJB7rczzTqBBB","reqId":1532033264248749},"type":"0"},"txnMetadata":{"seqNo":39,"txnTime":1532033227},"ver":"1"}"#,
r#"{"reqSignature":{"type":"ED25519","values":[{"from":"6feBTywcmJUriqqnGc1zSJ","value":"tkPNgpHinWAPXvkbvnphC54pauknphTCMF5gzG5AHT1EUHJGS3bQnDi7UKNEYKAjujExWYJAHtM5iydk26yatBK"}]},"txn":{"data":{"data":{"alias":"valNode01","services":[]},"dest":"AYQcyJvowniMsxU9P93yzyAPCFUxg7hm1xsXitFoBr6z"},"metadata":{"digest":"a8eebd86b4cc9aa422f1fc3e6950def9498e7f51b1d9a720ba68413e53ccfbe9","from":"6feBTywcmJUriqqnGc1zSJ","reqId":1532035631471362345},"type":"0"},"txnMetadata":{"seqNo":40,"txnTime":1532035631},"ver":"1"}"#,
r#"{"reqSignature":{"type":"ED25519","values":[{"from":"Psfx4mLS23gBvZDoWz336H","value":"5VVAPQH1LaZmJ4XG1kKxnmUXawg9nTVc1kwULndbFR9yk19mT3vaM9DES342cBYmrpXuY8zQwsXHk4kSoBqZvezi"}]},"txn":{"data":{"data":{"alias":"trustscience-validator01","blskey":"2ToF3Pfb78JQ3pFs6mYxtofDnHLTBLP2RKCDfn6eVngN4zh4UiHvz9DuUS2dfTpAeZLqBDkKuU9pYRazeDN9fqWgzk6kgZYf8jeWgra7rk33ZbZjHFz1zQjNMk3eju5n9JNY4AFbUcXCTWCdFoSXF9fEySKuNANPqtFNz92H2VjrySF","client_ip":"54.214.176.123","client_port":9702,"node_ip":"54.214.176.123","node_port":9701,"services":["VALIDATOR"]},"dest":"8Tqj57DbizpjWQCHvybtKNqKFgfw2bjJbPZrhHDoRoND"},"metadata":{"digest":"d2612092e47da9a0bfb8c9367d0149927abe50aca98ed127b8cfd9b5975b290b","from":"Psfx4mLS23gBvZDoWz336H","reqId":1532121668250427244},"type":"0"},"txnMetadata":{"seqNo":41,"txnTime":1532121629},"ver":"1"}"#,
r#"{"reqSignature":{"type":"ED25519","values":[{"from":"6feBTywcmJUriqqnGc1zSJ","value":"5gVt2TSEFpJHWN3BwMn1YgcURpxtGfijmXjGu6Cf5CXkwTmTp4dhUN5Ue6WFZU7PcKSrKfu8PvroWPHCiP7AsMvL"}]},"txn":{"data":{"data":{"alias":"amihan-sovrin","services":[]},"dest":"2FZAgVmRC87ZbJXSh6seFi6n7AMfBo9HaCh8HseHi37U"},"metadata":{"digest":"4141b470e5def16f7fde7c3ee5efc02f712bc0e5260a59709385417047516736","from":"6feBTywcmJUriqqnGc1zSJ","reqId":1532979260947795461},"type":"0"},"txnMetadata":{"seqNo":42,"txnTime":1532979261},"ver":"1"}"#,
r#"{"reqSignature":{"type":"ED25519","values":[{"from":"6feBTywcmJUriqqnGc1zSJ","value":"4A2vM1MT3vxNdASCpxgYfzNajpYScAipcRoSyUaRkH9dZ4CmfhHjWogS7VF7WLRNXKUssQVG2DdLrUzuFEckaM6e"}]},"txn":{"data":{"data":{"alias":"findentity","services":[]},"dest":"5bQhBNkoFKCFAtCxe1vcXBoq6FsnJ3nWKYwUfyVS3129"},"metadata":{"digest":"06ee3b89112f96f93df9f91554b5f4ada39ef34dbc4dd198ab7bc60e0d2f0c57","from":"6feBTywcmJUriqqnGc1zSJ","reqId":1532979375523513444},"type":"0"},"txnMetadata":{"seqNo":43,"txnTime":1532979375},"ver":"1"}"#,
r#"{"reqSignature":{"type":"ED25519","values":[{"from":"6feBTywcmJUriqqnGc1zSJ","value":"5tqAZojtpBxCaTkLvX6Why6MYyofYTUEt8taHxyXRBPrDugsCZjM5aRxEwXak7qNuUJGt2x9LMfVLdB81rk8yR2e"}]},"txn":{"data":{"data":{"alias":"VeridiumIDC","services":[]},"dest":"58uCeMaEiMHSi8MdEdcgVbpmzMKmiLSYCEz1vxPGJND6"},"metadata":{"digest":"aca82cab749e9d722134d46f0891269fcae59b7fd065fb3155dd632e2f740322","from":"6feBTywcmJUriqqnGc1zSJ","reqId":1532979478035983569},"type":"0"},"txnMetadata":{"seqNo":44,"txnTime":1532979478},"ver":"1"}"#,
| rust | Apache-2.0 | 2d3034ed73ba8d49e0f72251b4c7cfb859a1efe7 | 2026-01-04T20:24:59.602734Z | true |
openwallet-foundation/vcx | https://github.com/openwallet-foundation/vcx/blob/2d3034ed73ba8d49e0f72251b4c7cfb859a1efe7/aries/aries_vcx_ledger/src/ledger/request_submitter/vdr_proxy.rs | aries/aries_vcx_ledger/src/ledger/request_submitter/vdr_proxy.rs | use std::sync::Arc;
use async_trait::async_trait;
use indy_vdr::pool::PreparedRequest;
use indy_vdr_proxy_client::VdrProxyClient;
use super::RequestSubmitter;
use crate::errors::error::VcxLedgerResult;
#[derive(Clone)]
pub struct VdrProxySubmitter {
client: Arc<VdrProxyClient>,
}
impl VdrProxySubmitter {
pub fn new(client: Arc<VdrProxyClient>) -> Self {
Self { client }
}
}
#[async_trait]
impl RequestSubmitter for VdrProxySubmitter {
async fn submit(&self, request: PreparedRequest) -> VcxLedgerResult<String> {
self.client.post(request).await.map_err(|e| e.into())
}
}
| rust | Apache-2.0 | 2d3034ed73ba8d49e0f72251b4c7cfb859a1efe7 | 2026-01-04T20:24:59.602734Z | false |
openwallet-foundation/vcx | https://github.com/openwallet-foundation/vcx/blob/2d3034ed73ba8d49e0f72251b4c7cfb859a1efe7/aries/aries_vcx_ledger/src/ledger/request_submitter/mod.rs | aries/aries_vcx_ledger/src/ledger/request_submitter/mod.rs | use async_trait::async_trait;
use indy_vdr::pool::PreparedRequest;
use crate::errors::error::VcxLedgerResult;
pub mod vdr_ledger;
#[cfg(feature = "vdr_proxy_ledger")]
pub mod vdr_proxy;
#[async_trait]
pub trait RequestSubmitter: Send + Sync {
async fn submit(&self, request: PreparedRequest) -> VcxLedgerResult<String>;
}
| rust | Apache-2.0 | 2d3034ed73ba8d49e0f72251b4c7cfb859a1efe7 | 2026-01-04T20:24:59.602734Z | false |
openwallet-foundation/vcx | https://github.com/openwallet-foundation/vcx/blob/2d3034ed73ba8d49e0f72251b4c7cfb859a1efe7/aries/aries_vcx_ledger/src/ledger/request_submitter/vdr_ledger.rs | aries/aries_vcx_ledger/src/ledger/request_submitter/vdr_ledger.rs | use std::{
collections::HashMap,
fmt::{Debug, Formatter},
sync::Arc,
};
use async_trait::async_trait;
use indy_vdr::{
common::error::VdrError,
config::PoolConfig,
pool::{
PoolBuilder, PoolRunner, PoolTransactions, PreparedRequest, RequestResult,
RequestResultMeta,
},
};
use log::info;
use tokio::sync::oneshot;
use super::RequestSubmitter;
use crate::errors::error::{VcxLedgerError, VcxLedgerResult};
#[derive(Clone)]
pub struct IndyVdrLedgerPool {
runner: Arc<PoolRunner>,
}
impl IndyVdrLedgerPool {
pub fn new_from_runner(runner: PoolRunner) -> Self {
IndyVdrLedgerPool {
runner: Arc::new(runner),
}
}
fn generate_exclusion_weights(exclude_nodes: Vec<String>) -> HashMap<String, f32> {
exclude_nodes
.into_iter()
.map(|node| (node, 0.0f32))
.collect()
}
pub fn new(
genesis_file_path: String,
indy_vdr_config: PoolConfig,
exclude_nodes: Vec<String>,
) -> VcxLedgerResult<Self> {
info!(
"IndyVdrLedgerPool::new >> genesis_file_path: {genesis_file_path}, indy_vdr_config: \
{indy_vdr_config:?}"
);
let txns = PoolTransactions::from_json_file(genesis_file_path)?;
let runner = PoolBuilder::new(indy_vdr_config, txns)
.node_weights(Some(Self::generate_exclusion_weights(exclude_nodes)))
.into_runner(None)?;
Ok(IndyVdrLedgerPool {
runner: Arc::new(runner),
})
}
}
impl Debug for IndyVdrLedgerPool {
fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
f.debug_struct("IndyVdrLedgerPool")
.field("runner", &"PoolRunner")
.finish()
}
}
#[derive(Clone, Debug)]
pub struct IndyVdrSubmitter {
pool: IndyVdrLedgerPool,
}
impl IndyVdrSubmitter {
pub fn new(pool: IndyVdrLedgerPool) -> Self {
Self { pool }
}
}
#[async_trait]
impl RequestSubmitter for IndyVdrSubmitter {
async fn submit(&self, request: PreparedRequest) -> VcxLedgerResult<String> {
// indyvdr send_request is Async via a callback.
// Use oneshot channel to send result from callback, converting the fn to future.
type VdrSendRequestResult = Result<(RequestResult<String>, RequestResultMeta), VdrError>;
let (sender, recv) = oneshot::channel::<VdrSendRequestResult>();
self.pool.runner.send_request(
request,
Box::new(move |result| {
// unable to handle a failure from `send` here
sender.send(result).ok();
}),
)?;
let send_req_result: VdrSendRequestResult = recv
.await
.map_err(|e| VcxLedgerError::InvalidState(e.to_string()))?;
let (result, _) = send_req_result?;
let reply = match result {
RequestResult::Reply(reply) => Ok(reply),
RequestResult::Failed(failed) => Err(failed),
};
Ok(reply?)
}
}
| rust | Apache-2.0 | 2d3034ed73ba8d49e0f72251b4c7cfb859a1efe7 | 2026-01-04T20:24:59.602734Z | false |
openwallet-foundation/vcx | https://github.com/openwallet-foundation/vcx/blob/2d3034ed73ba8d49e0f72251b4c7cfb859a1efe7/aries/aries_vcx_ledger/src/ledger/response_cacher/mod.rs | aries/aries_vcx_ledger/src/ledger/response_cacher/mod.rs | pub mod in_memory;
pub mod noop;
use async_trait::async_trait;
use serde::{Deserialize, Serialize};
use crate::errors::error::VcxLedgerResult;
#[async_trait]
pub trait ResponseCacher: Send + Sync {
type Options: Send + Sync;
async fn put<S, T>(&self, id: S, obj: T) -> VcxLedgerResult<()>
where
S: ToString + Send,
T: Serialize + for<'de> Deserialize<'de> + Send;
async fn get<S, T>(&self, id: S, opt: Option<Self::Options>) -> VcxLedgerResult<Option<T>>
where
S: ToString + Send,
T: Serialize + for<'de> Deserialize<'de> + Send;
}
| rust | Apache-2.0 | 2d3034ed73ba8d49e0f72251b4c7cfb859a1efe7 | 2026-01-04T20:24:59.602734Z | false |
openwallet-foundation/vcx | https://github.com/openwallet-foundation/vcx/blob/2d3034ed73ba8d49e0f72251b4c7cfb859a1efe7/aries/aries_vcx_ledger/src/ledger/response_cacher/noop/mod.rs | aries/aries_vcx_ledger/src/ledger/response_cacher/noop/mod.rs | use async_trait::async_trait;
use serde::{Deserialize, Serialize};
use super::ResponseCacher;
use crate::errors::error::VcxLedgerResult;
pub struct NoopResponseCacher;
#[async_trait]
impl ResponseCacher for NoopResponseCacher {
type Options = ();
async fn put<S, T>(&self, _id: S, _obj: T) -> VcxLedgerResult<()>
where
S: ToString + Send,
T: Serialize + for<'de> Deserialize<'de> + Send,
{
Ok(())
}
async fn get<S, T>(&self, _id: S, _opt: Option<Self::Options>) -> VcxLedgerResult<Option<T>>
where
S: ToString + Send,
T: Serialize + for<'de> Deserialize<'de> + Send,
{
Ok(None)
}
}
| rust | Apache-2.0 | 2d3034ed73ba8d49e0f72251b4c7cfb859a1efe7 | 2026-01-04T20:24:59.602734Z | false |
openwallet-foundation/vcx | https://github.com/openwallet-foundation/vcx/blob/2d3034ed73ba8d49e0f72251b4c7cfb859a1efe7/aries/aries_vcx_ledger/src/ledger/response_cacher/in_memory/config.rs | aries/aries_vcx_ledger/src/ledger/response_cacher/in_memory/config.rs | use std::{num::NonZeroUsize, time::Duration};
use serde::Deserialize;
use crate::errors::error::VcxLedgerError;
#[derive(Clone, Debug, Deserialize)]
pub struct InMemoryResponseCacherConfig {
ttl: Duration,
capacity: NonZeroUsize,
}
impl InMemoryResponseCacherConfig {
pub fn builder() -> InMemoryResponseCacherConfigBuilder {
InMemoryResponseCacherConfigBuilder::default()
}
pub fn ttl(&self) -> Duration {
self.ttl
}
pub fn capacity(&self) -> NonZeroUsize {
self.capacity
}
}
#[derive(Default)]
pub struct InMemoryResponseCacherConfigBuilder {}
pub struct InMemoryResponseCacherConfigBuilderTtlSet {
ttl: Duration,
}
pub struct InMemoryResponseCacherConfigBuilderReady {
ttl: Duration,
capacity: NonZeroUsize,
}
impl InMemoryResponseCacherConfigBuilder {
pub fn ttl(self, ttl: Duration) -> InMemoryResponseCacherConfigBuilderTtlSet {
InMemoryResponseCacherConfigBuilderTtlSet { ttl }
}
}
impl InMemoryResponseCacherConfigBuilderTtlSet {
pub fn capacity(
self,
capacity: usize,
) -> Result<InMemoryResponseCacherConfigBuilderReady, VcxLedgerError> {
let capacity = NonZeroUsize::new(capacity).ok_or(VcxLedgerError::InvalidOption(
"Failed to parse cache capacity into NonZeroUsize".into(),
))?;
Ok(InMemoryResponseCacherConfigBuilderReady {
ttl: self.ttl,
capacity,
})
}
}
impl InMemoryResponseCacherConfigBuilderReady {
pub fn build(self) -> InMemoryResponseCacherConfig {
InMemoryResponseCacherConfig {
ttl: self.ttl,
capacity: self.capacity,
}
}
}
| rust | Apache-2.0 | 2d3034ed73ba8d49e0f72251b4c7cfb859a1efe7 | 2026-01-04T20:24:59.602734Z | false |
openwallet-foundation/vcx | https://github.com/openwallet-foundation/vcx/blob/2d3034ed73ba8d49e0f72251b4c7cfb859a1efe7/aries/aries_vcx_ledger/src/ledger/response_cacher/in_memory/options.rs | aries/aries_vcx_ledger/src/ledger/response_cacher/in_memory/options.rs | use std::time::Duration;
#[derive(Default)]
pub struct InMemoryResponseCacherOptions {
ttl: Option<Duration>,
}
impl InMemoryResponseCacherOptions {
pub fn builder() -> InMemoryResponseCacherOptionsBuilder {
InMemoryResponseCacherOptionsBuilder::default()
}
pub fn ttl(&self) -> Option<Duration> {
self.ttl
}
}
#[derive(Default)]
pub struct InMemoryResponseCacherOptionsBuilder {
ttl: Option<Duration>,
}
impl InMemoryResponseCacherOptionsBuilder {
pub fn ttl(mut self, ttl: Duration) -> Self {
self.ttl = Some(ttl);
self
}
pub fn build(self) -> InMemoryResponseCacherOptions {
InMemoryResponseCacherOptions { ttl: self.ttl }
}
}
| rust | Apache-2.0 | 2d3034ed73ba8d49e0f72251b4c7cfb859a1efe7 | 2026-01-04T20:24:59.602734Z | false |
openwallet-foundation/vcx | https://github.com/openwallet-foundation/vcx/blob/2d3034ed73ba8d49e0f72251b4c7cfb859a1efe7/aries/aries_vcx_ledger/src/ledger/response_cacher/in_memory/mod.rs | aries/aries_vcx_ledger/src/ledger/response_cacher/in_memory/mod.rs | mod config;
mod options;
use std::{sync::Arc, time::Instant};
use async_trait::async_trait;
pub use config::*;
use log::info;
use lru::LruCache;
pub use options::*;
use serde::{Deserialize, Serialize};
use tokio::sync::Mutex;
use super::ResponseCacher;
use crate::errors::error::VcxLedgerResult;
pub struct InMemoryResponseCacher {
cache: Arc<Mutex<LruCache<String, (String, Instant)>>>,
config: InMemoryResponseCacherConfig,
}
impl InMemoryResponseCacher {
pub fn new(config: InMemoryResponseCacherConfig) -> Self {
info!("InMemoryResponseCacher::new >> config: {config:?}");
Self {
cache: Arc::new(Mutex::new(LruCache::new(config.capacity()))),
config,
}
}
}
#[async_trait]
impl ResponseCacher for InMemoryResponseCacher {
type Options = InMemoryResponseCacherOptions;
async fn put<S, T>(&self, id: S, obj: T) -> VcxLedgerResult<()>
where
S: ToString + Send,
T: Serialize + for<'de> Deserialize<'de> + Send,
{
let id = id.to_string();
let obj = serde_json::to_string(&obj)?;
let mut cache = self.cache.lock().await;
cache.put(id, (obj, Instant::now()));
Ok(())
}
async fn get<S, T>(&self, id: S, opt: Option<Self::Options>) -> VcxLedgerResult<Option<T>>
where
S: ToString + Send,
T: Serialize + for<'de> Deserialize<'de> + Send,
{
let id = id.to_string();
let ttl = if let Some(opt) = opt {
opt.ttl().unwrap_or(self.config.ttl())
} else {
self.config.ttl()
};
let mut cache = self.cache.lock().await;
match cache.get(&id) {
Some((obj, timestamp)) => {
if timestamp.elapsed() > ttl {
cache.pop(&id);
Ok(None)
} else {
let obj: T = serde_json::from_str(obj)?;
Ok(Some(obj))
}
}
None => Ok(None),
}
}
}
#[cfg(test)]
mod tests {
use std::time::Duration;
use super::*;
#[derive(Serialize, Deserialize, PartialEq, Debug, Clone)]
struct TestStruct {
field: String,
}
fn _cacher_config(ttl: Duration) -> InMemoryResponseCacherConfig {
InMemoryResponseCacherConfig::builder()
.ttl(ttl)
.capacity(2)
.unwrap()
.build()
}
fn _cacher_options(ttl: Duration) -> InMemoryResponseCacherOptions {
InMemoryResponseCacherOptions::builder().ttl(ttl).build()
}
fn _test_object() -> TestStruct {
TestStruct {
field: "test".to_string(),
}
}
#[tokio::test]
async fn test_put_and_get() -> VcxLedgerResult<()> {
let cacher = InMemoryResponseCacher::new(_cacher_config(Duration::from_secs(1)));
let test_object = _test_object();
cacher.put("id1", test_object.clone()).await?;
let cached_object: Option<TestStruct> = cacher.get("id1", None).await?;
assert_eq!(Some(test_object), cached_object);
Ok(())
}
#[tokio::test]
async fn test_expiration() -> VcxLedgerResult<()> {
let cacher = InMemoryResponseCacher::new(_cacher_config(Duration::from_millis(1)));
let test_object = _test_object();
cacher.put("id1", test_object).await?;
tokio::time::sleep(Duration::from_millis(1)).await;
let cached_object: Option<TestStruct> = cacher.get("id1", None).await?;
assert_eq!(None, cached_object);
Ok(())
}
#[tokio::test]
async fn test_capacity() -> VcxLedgerResult<()> {
let cacher = InMemoryResponseCacher::new(_cacher_config(Duration::from_secs(1)));
let test_object = _test_object();
cacher.put("id1", test_object.clone()).await?;
cacher.put("id2", test_object.clone()).await?;
cacher.put("id3", test_object).await?;
let cached_object: Option<TestStruct> = cacher.get("id1", None).await?;
assert_eq!(None, cached_object);
Ok(())
}
#[tokio::test]
async fn test_nonexistent_key() -> VcxLedgerResult<()> {
let cacher = InMemoryResponseCacher::new(_cacher_config(Duration::from_secs(1)));
let cached_object: Option<TestStruct> = cacher.get("nonexistent", None).await?;
assert_eq!(None, cached_object);
Ok(())
}
#[tokio::test]
async fn test_get_options_ttl_override_global_config_ttl() -> VcxLedgerResult<()> {
let cacher = InMemoryResponseCacher::new(_cacher_config(Duration::from_millis(1)));
let test_object = _test_object();
cacher.put("id1", test_object.clone()).await?;
tokio::time::sleep(Duration::from_millis(1)).await;
let cached_object: Option<TestStruct> = cacher
.get("id1", Some(_cacher_options(Duration::from_millis(10))))
.await?;
assert_eq!(Some(test_object), cached_object);
Ok(())
}
}
| rust | Apache-2.0 | 2d3034ed73ba8d49e0f72251b4c7cfb859a1efe7 | 2026-01-04T20:24:59.602734Z | false |
openwallet-foundation/vcx | https://github.com/openwallet-foundation/vcx/blob/2d3034ed73ba8d49e0f72251b4c7cfb859a1efe7/aries/aries_vcx_ledger/src/ledger/cheqd/mod.rs | aries/aries_vcx_ledger/src/ledger/cheqd/mod.rs | use std::{fmt::Debug, sync::Arc};
use anoncreds_types::data_types::{
identifiers::{
cred_def_id::CredentialDefinitionId, issuer_id::IssuerId,
rev_reg_def_id::RevocationRegistryDefinitionId, schema_id::SchemaId,
},
ledger::{
cred_def::CredentialDefinition,
rev_reg::RevocationRegistry,
rev_reg_def::RevocationRegistryDefinition,
rev_reg_delta::RevocationRegistryDelta,
rev_status_list::RevocationStatusList,
schema::{AttributeNames, Schema},
},
};
use async_trait::async_trait;
use chrono::DateTime;
use did_cheqd::resolution::resolver::DidCheqdResolver;
use did_parser_nom::{Did, DidUrl};
use did_resolver::shared_types::did_resource::{DidResource, DidResourceMetadata};
use models::{
CheqdAnoncredsCredentialDefinition, CheqdAnoncredsRevocationRegistryDefinition,
CheqdAnoncredsRevocationStatusList, CheqdAnoncredsSchema,
};
use serde::{Deserialize, Serialize};
use url::Url;
use super::base_ledger::{AnoncredsLedgerRead, AnoncredsLedgerSupport};
use crate::errors::error::{VcxLedgerError, VcxLedgerResult};
mod models;
const SCHEMA_RESOURCE_TYPE: &str = "anonCredsSchema";
const CRED_DEF_RESOURCE_TYPE: &str = "anonCredsCredDef";
const REV_REG_DEF_RESOURCE_TYPE: &str = "anonCredsRevocRegDef";
const STATUS_LIST_RESOURCE_TYPE: &str = "anonCredsStatusList";
/// Struct for resolving anoncreds objects from cheqd ledgers using the cheqd
/// anoncreds object method: https://docs.cheqd.io/product/advanced/anoncreds.
///
/// Relies on a cheqd DID resolver ([DidCheqdResolver]) to fetch DID resources.
pub struct CheqdAnoncredsLedgerRead {
resolver: Arc<DidCheqdResolver>,
}
impl CheqdAnoncredsLedgerRead {
pub fn new(resolver: Arc<DidCheqdResolver>) -> Self {
Self { resolver }
}
fn check_resource_type(&self, resource: &DidResource, expected: &str) -> VcxLedgerResult<()> {
let rtyp = &resource.metadata.resource_type;
if rtyp != expected {
return Err(VcxLedgerError::InvalidLedgerResponse(format!(
"Returned resource is not expected type. Got {rtyp}, expected: {expected}"
)));
}
Ok(())
}
async fn get_rev_reg_def_with_resource_metadata(
&self,
rev_reg_id: &RevocationRegistryDefinitionId,
) -> VcxLedgerResult<(RevocationRegistryDefinition, DidResourceMetadata)> {
let url = DidUrl::parse(rev_reg_id.to_string())?;
let resource = self.resolver.resolve_resource(&url).await?;
self.check_resource_type(&resource, REV_REG_DEF_RESOURCE_TYPE)?;
let data: CheqdAnoncredsRevocationRegistryDefinition =
serde_json::from_slice(&resource.content)?;
Ok((
RevocationRegistryDefinition {
id: rev_reg_id.to_owned(),
revoc_def_type: data.revoc_def_type,
tag: data.tag,
cred_def_id: data.cred_def_id,
value: data.value,
issuer_id: extract_issuer_id(&url)?,
},
resource.metadata,
))
}
}
#[derive(Serialize, Deserialize, Debug, Clone)]
pub struct RevocationRegistryDefinitionAdditionalMetadata {
pub resource_name: String,
}
#[async_trait]
impl AnoncredsLedgerRead for CheqdAnoncredsLedgerRead {
type RevocationRegistryDefinitionAdditionalMetadata =
RevocationRegistryDefinitionAdditionalMetadata;
async fn get_schema(&self, schema_id: &SchemaId, _: Option<&Did>) -> VcxLedgerResult<Schema> {
let url = DidUrl::parse(schema_id.to_string())?;
let resource = self.resolver.resolve_resource(&url).await?;
self.check_resource_type(&resource, SCHEMA_RESOURCE_TYPE)?;
let data: CheqdAnoncredsSchema = serde_json::from_slice(&resource.content)?;
Ok(Schema {
id: schema_id.to_owned(),
seq_no: None,
name: data.name,
version: data.version,
attr_names: AttributeNames(data.attr_names),
issuer_id: extract_issuer_id(&url)?,
})
}
async fn get_cred_def(
&self,
cred_def_id: &CredentialDefinitionId,
_: Option<&Did>,
) -> VcxLedgerResult<CredentialDefinition> {
let url = DidUrl::parse(cred_def_id.to_string())?;
let resource = self.resolver.resolve_resource(&url).await?;
self.check_resource_type(&resource, CRED_DEF_RESOURCE_TYPE)?;
let data: CheqdAnoncredsCredentialDefinition = serde_json::from_slice(&resource.content)?;
Ok(CredentialDefinition {
id: cred_def_id.to_owned(),
schema_id: data.schema_id,
signature_type: data.signature_type,
tag: data.tag,
value: data.value,
issuer_id: extract_issuer_id(&url)?,
})
}
async fn get_rev_reg_def_json(
&self,
rev_reg_id: &RevocationRegistryDefinitionId,
) -> VcxLedgerResult<(
RevocationRegistryDefinition,
RevocationRegistryDefinitionAdditionalMetadata,
)> {
let (rev_reg_def, resource_meta) = self
.get_rev_reg_def_with_resource_metadata(rev_reg_id)
.await?;
let meta = RevocationRegistryDefinitionAdditionalMetadata {
resource_name: resource_meta.resource_name,
};
Ok((rev_reg_def, meta))
}
async fn get_rev_reg_delta_json(
&self,
_rev_reg_id: &RevocationRegistryDefinitionId,
_from: Option<u64>,
_to: Option<u64>,
) -> VcxLedgerResult<(RevocationRegistryDelta, u64)> {
// unsupported, to be removed: https://github.com/openwallet-foundation/vcx/issues/1309
Err(VcxLedgerError::UnimplementedFeature(
"get_rev_reg_delta_json not supported for cheqd".into(),
))
}
async fn get_rev_status_list(
&self,
rev_reg_id: &RevocationRegistryDefinitionId,
timestamp: u64,
rev_reg_def_meta: Option<&RevocationRegistryDefinitionAdditionalMetadata>,
) -> VcxLedgerResult<(RevocationStatusList, u64)> {
let rev_reg_def_url = DidUrl::parse(rev_reg_id.to_string())?;
// refetch if needed
let rev_reg_def_meta = match rev_reg_def_meta {
Some(v) => v,
None => &self.get_rev_reg_def_json(rev_reg_id).await?.1,
};
//credo-ts uses the metadata.name or fails (https://docs.cheqd.io/product/advanced/anoncreds/revocation-status-list#same-resource-name-different-resource-type)
let name = &rev_reg_def_meta.resource_name;
let did = rev_reg_def_url
.did()
.ok_or(VcxLedgerError::InvalidInput(format!(
"DID URL missing DID {rev_reg_def_url}"
)))?;
let resource_dt =
DateTime::from_timestamp(timestamp as i64, 0).ok_or(VcxLedgerError::InvalidInput(
format!("input status list timestamp is not valid {timestamp}"),
))?;
// assemble query
let xml_dt = resource_dt.to_rfc3339_opts(chrono::SecondsFormat::Millis, true);
let mut query = Url::parse(did)
.map_err(|e| VcxLedgerError::InvalidInput(format!("cannot parse DID as URL: {e}")))?;
query
.query_pairs_mut()
.append_pair("resourceType", STATUS_LIST_RESOURCE_TYPE)
.append_pair("resourceName", name)
.append_pair("resourceVersionTime", &xml_dt);
let query_url = DidUrl::parse(query.to_string())?;
let resource = self.resolver.resolve_resource(&query_url).await?;
self.check_resource_type(&resource, STATUS_LIST_RESOURCE_TYPE)?;
let data: CheqdAnoncredsRevocationStatusList = serde_json::from_slice(&resource.content)?;
let timestamp = resource.metadata.created.timestamp() as u64;
let status_list = RevocationStatusList {
rev_reg_def_id: Some(rev_reg_id.to_owned()),
issuer_id: extract_issuer_id(&rev_reg_def_url)?,
revocation_list: data.revocation_list,
accum: data.accum,
timestamp: Some(timestamp),
};
Ok((status_list, timestamp))
}
async fn get_rev_reg(
&self,
rev_reg_id: &RevocationRegistryDefinitionId,
timestamp: u64,
) -> VcxLedgerResult<(RevocationRegistry, u64)> {
let (list, last_updated) = self
.get_rev_status_list(rev_reg_id, timestamp, None)
.await?;
let accum = list
.accum
.ok_or(VcxLedgerError::InvalidLedgerResponse(format!(
"response status list is missing an accumulator: {list:?}"
)))?;
let reg = RevocationRegistry {
value: accum.into(),
};
Ok((reg, last_updated))
}
}
fn extract_issuer_id(url: &DidUrl) -> VcxLedgerResult<IssuerId> {
let did = url.did().ok_or(VcxLedgerError::InvalidInput(format!(
"DID URL is missing a DID: {url}"
)))?;
IssuerId::new(did)
.map_err(|e| VcxLedgerError::InvalidInput(format!("DID is not an IssuerId {e}")))
}
impl AnoncredsLedgerSupport for CheqdAnoncredsLedgerRead {
fn supports_schema(&self, id: &SchemaId) -> bool {
let Ok(url) = DidUrl::parse(id.to_string()) else {
return false;
};
url.method() == Some("cheqd")
}
fn supports_credential_definition(&self, id: &CredentialDefinitionId) -> bool {
let Ok(url) = DidUrl::parse(id.to_string()) else {
return false;
};
url.method() == Some("cheqd")
}
fn supports_revocation_registry(&self, id: &RevocationRegistryDefinitionId) -> bool {
let Ok(url) = DidUrl::parse(id.to_string()) else {
return false;
};
url.method() == Some("cheqd")
}
}
impl Debug for CheqdAnoncredsLedgerRead {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
write!(f, "CheqdAnoncredsLedgerRead instance")
}
}
#[cfg(test)]
mod unit_tests {
use super::*;
fn default_cheqd_reader() -> CheqdAnoncredsLedgerRead {
CheqdAnoncredsLedgerRead::new(Arc::new(DidCheqdResolver::new(Default::default())))
}
#[test]
fn test_anoncreds_schema_support() {
let reader = default_cheqd_reader();
// qualified cheqd
assert!(reader.supports_schema(
&SchemaId::new(
"did:cheqd:mainnet:7BPMqYgYLQni258J8JPS8K/resources/\
6259d357-eeb1-4b98-8bee-12a8390d3497"
)
.unwrap()
));
// unqualified
assert!(!reader.supports_schema(
&SchemaId::new("7BPMqYgYLQni258J8JPS8K:2:degree schema:46.58.87").unwrap()
));
// qualified sov
assert!(!reader.supports_schema(
&SchemaId::new("did:sov:7BPMqYgYLQni258J8JPS8K:2:degree schema:46.58.87").unwrap()
));
}
#[test]
fn test_anoncreds_cred_def_support() {
let reader = default_cheqd_reader();
// qualified cheqd
assert!(reader.supports_credential_definition(
&CredentialDefinitionId::new(
"did:cheqd:mainnet:7BPMqYgYLQni258J8JPS8K/resources/\
6259d357-eeb1-4b98-8bee-12a8390d3497"
)
.unwrap()
));
// unqualified
assert!(!reader.supports_credential_definition(
&CredentialDefinitionId::new(
"7BPMqYgYLQni258J8JPS8K:3:CL:70:faber.agent.degree_schema"
)
.unwrap()
));
// qualified sov
assert!(!reader.supports_credential_definition(
&CredentialDefinitionId::new(
"did:sov:7BPMqYgYLQni258J8JPS8K:3:CL:70:faber.agent.degree_schema"
)
.unwrap()
));
}
#[test]
fn test_anoncreds_rev_reg_support() {
let reader = default_cheqd_reader();
// qualified cheqd
assert!(reader.supports_revocation_registry(
&RevocationRegistryDefinitionId::new(
"did:cheqd:mainnet:7BPMqYgYLQni258J8JPS8K/resources/\
6259d357-eeb1-4b98-8bee-12a8390d3497"
)
.unwrap()
));
// unqualified
assert!(!reader.supports_revocation_registry(
&RevocationRegistryDefinitionId::new(
"7BPMqYgYLQni258J8JPS8K:4:7BPMqYgYLQni258J8JPS8K:3:CL:70:faber.agent.\
degree_schema:CL_ACCUM:61d5a381-30be-4120-9307-b150b49c203c"
)
.unwrap()
));
// qualified sov
assert!(!reader.supports_revocation_registry(
&RevocationRegistryDefinitionId::new(
"did:sov:7BPMqYgYLQni258J8JPS8K:4:7BPMqYgYLQni258J8JPS8K:3:CL:70:faber.agent.\
degree_schema:CL_ACCUM:61d5a381-30be-4120-9307-b150b49c203c"
)
.unwrap()
));
}
}
| rust | Apache-2.0 | 2d3034ed73ba8d49e0f72251b4c7cfb859a1efe7 | 2026-01-04T20:24:59.602734Z | false |
openwallet-foundation/vcx | https://github.com/openwallet-foundation/vcx/blob/2d3034ed73ba8d49e0f72251b4c7cfb859a1efe7/aries/aries_vcx_ledger/src/ledger/cheqd/models.rs | aries/aries_vcx_ledger/src/ledger/cheqd/models.rs | //! Cheqd Ledger data models, derived from https://docs.cheqd.io/product/advanced/anoncreds
use anoncreds_types::data_types::{
identifiers::{cred_def_id::CredentialDefinitionId, schema_id::SchemaId},
ledger::{
cred_def::{CredentialDefinitionData, SignatureType},
rev_reg_def::{RegistryType, RevocationRegistryDefinitionValue},
rev_status_list::serde_revocation_list,
},
};
use serde::{Deserialize, Serialize};
#[derive(Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct CheqdAnoncredsSchema {
pub name: String,
pub version: String,
pub attr_names: Vec<String>,
}
#[derive(Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct CheqdAnoncredsCredentialDefinition {
pub schema_id: SchemaId,
#[serde(rename = "type")]
pub signature_type: SignatureType,
pub tag: String,
pub value: CredentialDefinitionData,
}
#[derive(Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct CheqdAnoncredsRevocationRegistryDefinition {
pub revoc_def_type: RegistryType,
pub cred_def_id: CredentialDefinitionId,
pub tag: String,
pub value: RevocationRegistryDefinitionValue,
}
#[derive(Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct CheqdAnoncredsRevocationStatusList {
#[serde(with = "serde_revocation_list")]
pub revocation_list: bitvec::vec::BitVec,
#[serde(
rename = "currentAccumulator",
alias = "accum",
skip_serializing_if = "Option::is_none"
)]
pub accum: Option<anoncreds_types::cl::Accumulator>,
}
| rust | Apache-2.0 | 2d3034ed73ba8d49e0f72251b4c7cfb859a1efe7 | 2026-01-04T20:24:59.602734Z | false |
openwallet-foundation/vcx | https://github.com/openwallet-foundation/vcx/blob/2d3034ed73ba8d49e0f72251b4c7cfb859a1efe7/aries/aries_vcx_ledger/tests/test_cheqd.rs | aries/aries_vcx_ledger/tests/test_cheqd.rs | #[cfg(feature = "cheqd")]
mod test_cheqd {
use std::sync::Arc;
use anoncreds_types::data_types::identifiers::{
cred_def_id::CredentialDefinitionId, rev_reg_def_id::RevocationRegistryDefinitionId,
schema_id::SchemaId,
};
use aries_vcx_ledger::ledger::{
base_ledger::AnoncredsLedgerRead, cheqd::CheqdAnoncredsLedgerRead,
};
use chrono::{DateTime, Utc};
use did_cheqd::resolution::resolver::DidCheqdResolver;
use serde_json::json;
#[tokio::test]
async fn test_resolve_schema_vector() {
let id = "did:cheqd:testnet:d37eba59-513d-42d3-8f9f-d1df0548b675/resources/\
a7e2fc0b-5f6c-466d-911f-3ed9909f98a0";
let reader =
CheqdAnoncredsLedgerRead::new(Arc::new(DidCheqdResolver::new(Default::default())));
let schema = reader
.get_schema(&SchemaId::new_unchecked(id), None)
.await
.unwrap();
assert_eq!(
schema.id.0,
"did:cheqd:testnet:d37eba59-513d-42d3-8f9f-d1df0548b675/resources/\
a7e2fc0b-5f6c-466d-911f-3ed9909f98a0"
);
assert!(schema.seq_no.is_none());
assert_eq!(
schema.name,
"Faber College221a463c-9160-41bd-839c-26c0154e64b4"
);
assert_eq!(schema.version, "1.0.0");
assert_eq!(
schema.attr_names.0,
vec!["name".to_string(), "degree".to_string(), "date".to_string()]
);
assert_eq!(
schema.issuer_id.0,
"did:cheqd:testnet:d37eba59-513d-42d3-8f9f-d1df0548b675"
);
}
#[tokio::test]
async fn test_resolve_cred_def_vector() {
let id = "did:cheqd:testnet:e5d13e49-9f5d-4ec1-b0f6-43e43e211fdc/resources/\
796f4d32-ceb2-4549-ac2f-5270442066ee";
let reader =
CheqdAnoncredsLedgerRead::new(Arc::new(DidCheqdResolver::new(Default::default())));
let cred_def = reader
.get_cred_def(&CredentialDefinitionId::new_unchecked(id), None)
.await
.unwrap();
let expected_cred_def = json!({
"id": "did:cheqd:testnet:e5d13e49-9f5d-4ec1-b0f6-43e43e211fdc/resources/796f4d32-ceb2-4549-ac2f-5270442066ee",
"schemaId": "did:cheqd:testnet:e5d13e49-9f5d-4ec1-b0f6-43e43e211fdc/resources/441dd8ac-5132-4f64-a899-b95e6631861e",
"issuerId": "did:cheqd:testnet:e5d13e49-9f5d-4ec1-b0f6-43e43e211fdc",
"type": "CL",
"tag": "default",
"value": {
"primary": {
"n": "101775425686705322446321729042513323885366249575341827532852151406029439141945446540758073370857140650173543806620665009319990704696336867406228341102050525062347572470125847326218665243292282264450928863478570405137509031729993280909749863406879170040618211281523178059425360274769809374009133917080596452472404002929533556061638640203000980751755775872098282217341230637597866343991247907713086791452810236342936381540330526648988208357641862302546515645514361066795780511377402835905056549804798920667891392124801399775162573084938362756949887199195057995844386465801420665147294058855188546320799079663835174965161",
"s": "87624888798698822624423723118022809956578348937987561814948126500576219529138836392203224198856904274580002516694066594875873709134352028429835540535481267491635062762312964551217817275494607969045880749427396603031296648191143611156088073589185938269488488710758969627092198856856923016111781105026554515570693238770759473619839075955094865571664244739744514364819888950198503617844415579864953624998989292124086306326904837728507294638098267220789662137529137088453854836926570472177996704875536555330577801472880881494686752967061366433608898978631273502532992063649958617359359105975313298611541375812686478449038",
"r": {
"master_secret": "91924390643616684447850600547636799126754942750676961814085841416767517190041327602185387580658201961018441581408151006589910605450989653472590754296936606411587277500591300185962955561382125964973024308169242022915814560288197996510864084499323589139928149142636050230482921777834206450457769957179088070681863843269743734589083210580654397696548923614457471055030224454430850991434040684872112181784382757277123431379517419634053875223449800478697799219665093330299855414452721993787344846427989123844376930340324838760730841881922239261134345165306574342224223006710126470962389247658692615899692622733364593917564",
"dataload": "67714311012680607861506009159005649926100729749085079545683454286626632138688065577440485138428200490485338821059098371694307470028480026620243200576189622077496672555428629091259952610415973355058680447309063025743992477107070451623444621247413013233746035427316025697312475570466580668335703497887313077562889740624862997672438829468032595482449521331150586223865869041877654993640507137080181293240650234816519778512756819260970205819993241324592879273813227162717013131055606974830594578099412351827306325727807837670155477487273346541222802392212114521431844422126972523175992819888243089660896279345668836709183"
},
"rctxt": "70939857802453506951149531957606930306640909143475371737027498474152925628494791068427574134203017421399121411176717498176846791145767680818780201808144435771494206471213311901071561885391866584823165735626586292923926605780832222900819531483444405585980754893162270863536237119860353096313485759974542267053904367917010014776300492094349532540865655521444795825149399229035168301897753439893554059797022750502266578483363311220307405821402958792359030164217593034199227560018630509640528678991350608730838863727066178052927862093157207477972326979317508513953451471067387162273207269626177777770178388199904693271885",
"z": "67232321822071084762251502223976923452971987672236221455852097322998038231254751227728590284858878856391984973291870462921522030038401971062122863827666305436738444365691249161806642192223615405177957760215302017704093487843885193856291620515859197624091514138527124658905269978674424356277491558952327833769860308310713639320922734643110516571614031976998124656051686500162012298658320291610287606636134513132238361082981123202624198501889516057149568201642936231925672511435865393828765935813568402464860650327397205857299165873490962876370815478186692229961439123671741775783729284710421491763990499547934996243081"
}
}
});
assert_eq!(serde_json::to_value(cred_def).unwrap(), expected_cred_def);
}
// https://testnet-explorer.cheqd.io/transactions/92C31ED20512FEE73EA4D8A6C8E63E652AA61A14D4F8C00203312EA185419CB9
#[tokio::test]
async fn test_resolve_rev_reg_def_vector() {
let id = "did:cheqd:testnet:8bbd2026-03f5-42c7-bf80-09f46fc4d67b/resources/\
4f265d83-4657-4c37-ba80-c66cc399457e";
let reader =
CheqdAnoncredsLedgerRead::new(Arc::new(DidCheqdResolver::new(Default::default())));
let (rev_reg_def, meta) = reader
.get_rev_reg_def_json(&RevocationRegistryDefinitionId::new_unchecked(id))
.await
.unwrap();
let expected_rev_reg_def = json!({
"id": id,
"issuerId": "did:cheqd:testnet:8bbd2026-03f5-42c7-bf80-09f46fc4d67b",
"credDefId": "did:cheqd:testnet:8bbd2026-03f5-42c7-bf80-09f46fc4d67b/resources/8372c1bc-907d-44a9-86be-ac3672b26e2e",
"revocDefType": "CL_ACCUM",
"tag": "1.0",
"value": {
"maxCredNum": 5,
"publicKeys": {
"accumKey": {
"z": "1 10D3560CAE0591EEA7D7A63E1A362FC31448EF321E04FD75F248BBAF02DE9749 1 118C4B0C7F3D86D46C22D62BAE7E613B137A879B50EFDFC56451AB9012BA57A0 1 23D6952F9D058744D4930D1DE6D79548BDCA3EE8BAAF64B712668E52A1290547 1 14C4C4389D92A99C4DA7E6CC2BD0C82E2809D3CD202CD2F0AD6C33D75AA39049 1 174EACBC7981492A791A72D57C6CB9FE488A679C4A5674E4F3C247D73A827384 1 0172B8961122D4D825B282CA1CD1BBC3B8DC459994C9FE2827CDF74B3AB08D38 1 181159044E453DC59FF320E9E08C666176F6B9309E162E2DA4FC1DB3156F7B1F 1 2323CEBFB26C6D28CBAF5F87F155362C6FA14AFA0EBA7DE2B4154FE4082E30FD 1 2354CB1624B42A284B41E5B3B4489C2795DBA9B88A725005555FB698AFF97260 1 07EEEF48EF52E5B15FD4AC28F0DAEDE0A259A27500855992307518A0DBE29A83 1 00FE73BCDB27D1DAD37E4F0E424372CA9548F11B4EC977DCCCC53D99A5C66F36 1 07E9DC0DD2163A66EDA84CD6BF282C7E18CB821762B6047CA1AB9FBE94DC6546"
}
},
"tailsHash": "GW1bmjcMmtHnLwbWrabX4sWYVopJMEvQWgYMAEDmbJS3",
"tailsLocation": "GW1bmjcMmtHnLwbWrabX4sWYVopJMEvQWgYMAEDmbJS3"
}
});
assert_eq!(
serde_json::to_value(rev_reg_def).unwrap(),
expected_rev_reg_def
);
assert_eq!(
meta.resource_name,
"275990cc056b46176a7122cfd888f46a2bd8e3d45a71d5ff20764a874ed02edd"
);
}
// test status list resolution from credo-ts uploaded vectors
// https://resolver.cheqd.net/1.0/identifiers/did:cheqd:testnet:8bbd2026-03f5-42c7-bf80-09f46fc4d67b?resourceName=275990cc056b46176a7122cfd888f46a2bd8e3d45a71d5ff20764a874ed02edd&resourceType=anonCredsStatusList&resourceMetadata=true
// reset: https://testnet-explorer.cheqd.io/transactions/356F65125E585B9F439C423F2AD7DE73ADF4DC9A0811AA8EE5D03D63B1872DC0
// 2024-12-04T22:14:55Z
// update 1: https://testnet-explorer.cheqd.io/transactions/ADF7D562A5005576FA6EF8DC864DAA306EB62C40911FEB5B30C8F98968AE7B51
// 2024-12-04T22:15:07Z
// update 2: https://testnet-explorer.cheqd.io/transactions/222FF2D023C2C9A097BB38F3875F072DF8DEC7B0CBD46AC3459C9B4C3C74382F
// 2024-12-04T22:15:18Z
// update 3: https://testnet-explorer.cheqd.io/transactions/791D57B8C49C270B3EDA0E9E7E00811CA828190C2D6517FDE8E40CD8FE445E1C
// 2024-12-04T22:15:30Z
#[tokio::test]
async fn test_resolve_rev_status_list_versions() {
let def_id = "did:cheqd:testnet:8bbd2026-03f5-42c7-bf80-09f46fc4d67b/resources/\
4f265d83-4657-4c37-ba80-c66cc399457e";
let def_id = RevocationRegistryDefinitionId::new_unchecked(def_id);
let init_time = DateTime::parse_from_rfc3339("2024-12-04T22:14:55Z")
.unwrap()
.timestamp() as u64;
let update1_time = DateTime::parse_from_rfc3339("2024-12-04T22:15:07Z")
.unwrap()
.timestamp() as u64;
let update2_time = DateTime::parse_from_rfc3339("2024-12-04T22:15:18Z")
.unwrap()
.timestamp() as u64;
let update3_time = DateTime::parse_from_rfc3339("2024-12-04T22:15:30Z")
.unwrap()
.timestamp() as u64;
let reader =
CheqdAnoncredsLedgerRead::new(Arc::new(DidCheqdResolver::new(Default::default())));
let def_meta = reader.get_rev_reg_def_json(&def_id).await.unwrap().1;
// scenario 1: get most recent
let now = Utc::now().timestamp() as u64;
let (status_list, update_time) = reader
.get_rev_status_list(&def_id, now, Some(&def_meta))
.await
.unwrap();
assert_eq!(update_time, update3_time);
assert_eq!(
serde_json::to_value(status_list).unwrap(),
json!({
"issuerId": "did:cheqd:testnet:8bbd2026-03f5-42c7-bf80-09f46fc4d67b",
"revRegDefId": "did:cheqd:testnet:8bbd2026-03f5-42c7-bf80-09f46fc4d67b/resources/4f265d83-4657-4c37-ba80-c66cc399457e",
"revocationList": [1,1,1,1,0],
"currentAccumulator": "21 114BE4F2BBAAF18F07E994D74B28347FA0BEC500A616B47F57F2E0B0864F7602E 21 12AB68E307C5F2AA30F34A03ADB298C7F4C02555649E510919979C2AEB49CCDF1 6 5FB9FB957339A842130C84FC98240A163E56DC58B96423F1EFD53E9106671B94 4 28F2F8297E345FFF55CDEE87C83DE471486826C91EBBA2C39570A46013B5BFBA 6 565A830A4358E1F6F21A10804C23E36D739B5630C6A188D760F4B6F434D1311D 4 14F87165B42A780974AC70669DC3CF629F1103DF73AE15AC11A1151883A91941",
"timestamp": update3_time
})
);
// scenario 2: between update 2 & 3
let (status_list, update_time) = reader
.get_rev_status_list(&def_id, update2_time + 3, Some(&def_meta))
.await
.unwrap();
assert_eq!(update_time, update2_time);
assert_eq!(
serde_json::to_value(status_list).unwrap(),
json!({
"issuerId": "did:cheqd:testnet:8bbd2026-03f5-42c7-bf80-09f46fc4d67b",
"currentAccumulator": "21 125DF938B3B772619CB43E561D69004CF09667376E9CD53C818D84860BAE3D1D9 21 11ECFC5F9B469AC74E2A0E329F86C6E60B423A53CAC5AE7A4DBE7A978BFFC0DA1 6 6FAD628FED470FF640BF2C5DB57C2C18D009645DBEF15D4AF710739D2AD93E2D 4 22093A3300411B059B8BB7A8C3296A2ED9C4C8E00106C3B2BAD76E25AC792063 6 71D70ECA81BCE610D1C22CADE688AF4A122C8258E8B306635A111D0A35A7238A 4 1E80F38ABA3A966B8657D722D4E956F076BB2F5CCF36AA8942E65500F8898FF3",
"revRegDefId": "did:cheqd:testnet:8bbd2026-03f5-42c7-bf80-09f46fc4d67b/resources/4f265d83-4657-4c37-ba80-c66cc399457e",
"revocationList": [1,1,1,0,0],
"timestamp": update2_time
})
);
// scenario 3: between update 1 & 2
let (status_list, update_time) = reader
.get_rev_status_list(&def_id, update1_time + 3, Some(&def_meta))
.await
.unwrap();
assert_eq!(update_time, update1_time);
assert_eq!(
serde_json::to_value(status_list).unwrap(),
json!({
"issuerId": "did:cheqd:testnet:8bbd2026-03f5-42c7-bf80-09f46fc4d67b",
"currentAccumulator": "21 136FA865B5CD0AEA1DA05BE412C6E06C23066C338D39C5B79C5E1AE1D5BA20AAA 21 124182E098BE418B9DBECF600EEA3D070EDB85D6B412EE75B4B43C440FEA2E631 6 669D66FB3BC245B4EF892B8DB5A330ACA6A4CE6706FB58D9B487C0487DBB5C04 4 2C5C9551DFE2A4AE71D355DD3A981F155F51B9BCF8E2ED8B8263726DDF60D09C 6 7243CF31A80313C254F51D2B0A3573320B885178F36F4AE1E8FF4A520EF9CDCA 4 1B8DBE9563FAD9FBF8B75BCE41C9425E1D15EE0B3D195D0A86AD8A2C91D5BB73",
"revRegDefId": "did:cheqd:testnet:8bbd2026-03f5-42c7-bf80-09f46fc4d67b/resources/4f265d83-4657-4c37-ba80-c66cc399457e",
"revocationList": [1,1,0,0,0],
"timestamp": update1_time
})
);
// scenario 4: between init & update 1
let (status_list, update_time) = reader
.get_rev_status_list(&def_id, init_time + 3, Some(&def_meta))
.await
.unwrap();
assert_eq!(update_time, init_time);
assert_eq!(
serde_json::to_value(status_list).unwrap(),
json!({
"issuerId": "did:cheqd:testnet:8bbd2026-03f5-42c7-bf80-09f46fc4d67b",
"currentAccumulator": "1 0443A0BC791EE82B8F34066404B36E81E0CE68B64BD2A48A55587E4585B16CCA 1 0343A5D644B28DCC0EAF9C6D3E104DC0F61FCD711AFE93DB67031905DAA5F654 1 02CE577295DF112BB2C7F16250D4593FC922B074436EC0F4F124E2409EF99785 1 1692EE5DFE9885809DA503A2EEDC4EECDA5D7D415C743E3931576EFD72FB51AC 2 095E45DDF417D05FB10933FFC63D474548B7FFFF7888802F07FFFFFF7D07A8A8 1 0000000000000000000000000000000000000000000000000000000000000000",
"revRegDefId": "did:cheqd:testnet:8bbd2026-03f5-42c7-bf80-09f46fc4d67b/resources/4f265d83-4657-4c37-ba80-c66cc399457e",
"revocationList": [0,0,0,0,0],
"timestamp": init_time
})
);
}
}
| rust | Apache-2.0 | 2d3034ed73ba8d49e0f72251b4c7cfb859a1efe7 | 2026-01-04T20:24:59.602734Z | false |
openwallet-foundation/vcx | https://github.com/openwallet-foundation/vcx/blob/2d3034ed73ba8d49e0f72251b4c7cfb859a1efe7/aries/aries_vcx_ledger/tests/test_multi_ledger.rs | aries/aries_vcx_ledger/tests/test_multi_ledger.rs | #[cfg(feature = "cheqd")]
mod test_cheqd {
use std::sync::Arc;
use aries_vcx_ledger::{
errors::error::VcxLedgerResult,
ledger::{
cheqd::CheqdAnoncredsLedgerRead,
indy_vdr_ledger::{IndyVdrLedgerRead, IndyVdrLedgerReadConfig},
multi_ledger::MultiLedgerAnoncredsRead,
request_submitter::RequestSubmitter,
response_cacher::noop::NoopResponseCacher,
},
};
use async_trait::async_trait;
use did_cheqd::resolution::resolver::DidCheqdResolver;
use indy_vdr::pool::ProtocolVersion;
use mockall::mock;
mock! {
pub RequestSubmitter {}
#[async_trait]
impl RequestSubmitter for RequestSubmitter {
async fn submit(&self, request: indy_vdr::pool::PreparedRequest) -> VcxLedgerResult<String>;
}
}
fn dummy_indy_vdr_reader() -> IndyVdrLedgerRead<MockRequestSubmitter, NoopResponseCacher> {
IndyVdrLedgerRead::new(IndyVdrLedgerReadConfig {
request_submitter: MockRequestSubmitter::new(),
response_parser: indy_ledger_response_parser::ResponseParser,
response_cacher: NoopResponseCacher,
protocol_version: ProtocolVersion::Node1_4,
})
}
// asserts the successful construction using our defined anoncreds ledger readers.
#[test]
fn test_construction() {
let cheqd =
CheqdAnoncredsLedgerRead::new(Arc::new(DidCheqdResolver::new(Default::default())));
let indy = dummy_indy_vdr_reader();
let _multi_ledger = MultiLedgerAnoncredsRead::new()
.register_reader(cheqd)
.register_reader(indy);
}
}
| rust | Apache-2.0 | 2d3034ed73ba8d49e0f72251b4c7cfb859a1efe7 | 2026-01-04T20:24:59.602734Z | false |
openwallet-foundation/vcx | https://github.com/openwallet-foundation/vcx/blob/2d3034ed73ba8d49e0f72251b4c7cfb859a1efe7/aries/aries_vcx_anoncreds/src/lib.rs | aries/aries_vcx_anoncreds/src/lib.rs | pub mod anoncreds;
pub mod constants;
pub mod errors;
mod utils;
| rust | Apache-2.0 | 2d3034ed73ba8d49e0f72251b4c7cfb859a1efe7 | 2026-01-04T20:24:59.602734Z | false |
openwallet-foundation/vcx | https://github.com/openwallet-foundation/vcx/blob/2d3034ed73ba8d49e0f72251b4c7cfb859a1efe7/aries/aries_vcx_anoncreds/src/constants.rs | aries/aries_vcx_anoncreds/src/constants.rs | pub static DEFAULT_SERIALIZE_VERSION: &str = "1.0";
| rust | Apache-2.0 | 2d3034ed73ba8d49e0f72251b4c7cfb859a1efe7 | 2026-01-04T20:24:59.602734Z | false |
openwallet-foundation/vcx | https://github.com/openwallet-foundation/vcx/blob/2d3034ed73ba8d49e0f72251b4c7cfb859a1efe7/aries/aries_vcx_anoncreds/src/errors/mapping_anoncreds.rs | aries/aries_vcx_anoncreds/src/errors/mapping_anoncreds.rs | use anoncreds::{Error as AnoncredsError, ErrorKind};
use crate::errors::error::VcxAnoncredsError;
impl From<AnoncredsError> for VcxAnoncredsError {
fn from(err: AnoncredsError) -> Self {
match err.kind() {
ErrorKind::Input => VcxAnoncredsError::InvalidInput(err.to_string()),
ErrorKind::IOError => VcxAnoncredsError::IOError(err.to_string()),
ErrorKind::InvalidState => VcxAnoncredsError::InvalidState(err.to_string()),
ErrorKind::Unexpected => VcxAnoncredsError::UnknownError(err.to_string()),
ErrorKind::CredentialRevoked => VcxAnoncredsError::InvalidState(err.to_string()),
ErrorKind::InvalidUserRevocId => VcxAnoncredsError::InvalidInput(err.to_string()),
ErrorKind::ProofRejected => VcxAnoncredsError::ProofRejected(err.to_string()),
ErrorKind::RevocationRegistryFull => VcxAnoncredsError::InvalidState(err.to_string()),
}
}
}
| rust | Apache-2.0 | 2d3034ed73ba8d49e0f72251b4c7cfb859a1efe7 | 2026-01-04T20:24:59.602734Z | false |
openwallet-foundation/vcx | https://github.com/openwallet-foundation/vcx/blob/2d3034ed73ba8d49e0f72251b4c7cfb859a1efe7/aries/aries_vcx_anoncreds/src/errors/error.rs | aries/aries_vcx_anoncreds/src/errors/error.rs | use aries_vcx_wallet::errors::error::VcxWalletError;
use thiserror::Error as ThisError;
pub type VcxAnoncredsResult<T> = Result<T, VcxAnoncredsError>;
#[derive(Debug, ThisError)]
pub enum VcxAnoncredsError {
#[error("Invalid JSON: {0}")]
InvalidJson(String),
#[error("Invalid input: {0}")]
InvalidInput(String),
#[error("Invalid state: {0}")]
InvalidState(String),
#[error("Wallet error: {0}")]
WalletError(#[from] VcxWalletError),
#[error("Ursa error: {0}")]
UrsaError(String),
#[error("IO error: {0}")]
IOError(String),
#[error("Unknown error: {0}")]
UnknownError(String),
#[error("Proof rejected: {0}")]
ProofRejected(String),
#[error("Action not supported: {0}")]
ActionNotSupported(String),
#[error("Invalid proof request: {0}")]
InvalidProofRequest(String),
#[error("Invalid attributes structure: {0}")]
InvalidAttributesStructure(String),
#[error("Invalid option: {0}")]
InvalidOption(String),
#[error("Invalid schema: {0}")]
InvalidSchema(String),
#[error("Invalid master secret: {0}")]
DuplicationMasterSecret(String),
#[error("Unimplemented feature: {0}")]
UnimplementedFeature(String),
}
| rust | Apache-2.0 | 2d3034ed73ba8d49e0f72251b4c7cfb859a1efe7 | 2026-01-04T20:24:59.602734Z | false |
openwallet-foundation/vcx | https://github.com/openwallet-foundation/vcx/blob/2d3034ed73ba8d49e0f72251b4c7cfb859a1efe7/aries/aries_vcx_anoncreds/src/errors/mapping_others.rs | aries/aries_vcx_anoncreds/src/errors/mapping_others.rs | use super::error::VcxAnoncredsError;
impl From<serde_json::Error> for VcxAnoncredsError {
fn from(value: serde_json::Error) -> Self {
Self::InvalidJson(value.to_string())
}
}
impl From<Box<dyn std::error::Error>> for VcxAnoncredsError {
fn from(err: Box<dyn std::error::Error>) -> Self {
VcxAnoncredsError::InvalidState(err.to_string())
}
}
impl From<anoncreds_types::Error> for VcxAnoncredsError {
fn from(err: anoncreds_types::Error) -> Self {
VcxAnoncredsError::InvalidState(err.to_string())
}
}
| rust | Apache-2.0 | 2d3034ed73ba8d49e0f72251b4c7cfb859a1efe7 | 2026-01-04T20:24:59.602734Z | false |
openwallet-foundation/vcx | https://github.com/openwallet-foundation/vcx/blob/2d3034ed73ba8d49e0f72251b4c7cfb859a1efe7/aries/aries_vcx_anoncreds/src/errors/mod.rs | aries/aries_vcx_anoncreds/src/errors/mod.rs | pub mod error;
#[cfg(feature = "anoncreds")]
mod mapping_anoncreds;
mod mapping_others;
| rust | Apache-2.0 | 2d3034ed73ba8d49e0f72251b4c7cfb859a1efe7 | 2026-01-04T20:24:59.602734Z | false |
openwallet-foundation/vcx | https://github.com/openwallet-foundation/vcx/blob/2d3034ed73ba8d49e0f72251b4c7cfb859a1efe7/aries/aries_vcx_anoncreds/src/utils/json.rs | aries/aries_vcx_anoncreds/src/utils/json.rs | extern crate serde;
extern crate serde_json;
use std::string::String;
use serde_json::{Map, Value};
use crate::errors::error::{VcxAnoncredsError, VcxAnoncredsResult};
#[allow(unused)]
// some methods not used yet or by all features, but still a useful util
pub(crate) trait AsTypeOrDeserializationError {
fn try_as_str(&self) -> VcxAnoncredsResult<&str>;
fn try_as_object(&self) -> VcxAnoncredsResult<&Map<String, Value>>;
fn try_as_bool(&self) -> VcxAnoncredsResult<bool>;
fn try_as_array(&self) -> VcxAnoncredsResult<&Vec<Value>>;
}
impl AsTypeOrDeserializationError for &Value {
fn try_as_str(&self) -> VcxAnoncredsResult<&str> {
self.as_str().ok_or(VcxAnoncredsError::InvalidJson(format!(
"Could not deserialize '{self}' value as string"
)))
}
fn try_as_object(&self) -> VcxAnoncredsResult<&Map<String, Value>> {
self.as_object()
.ok_or(VcxAnoncredsError::InvalidJson(format!(
"Could not deserialize '{self}' value as object"
)))
}
fn try_as_bool(&self) -> VcxAnoncredsResult<bool> {
self.as_bool().ok_or(VcxAnoncredsError::InvalidJson(format!(
"Could not deserialize '{self}' value as bool"
)))
}
fn try_as_array(&self) -> VcxAnoncredsResult<&Vec<Value>> {
self.as_array()
.ok_or(VcxAnoncredsError::InvalidJson(format!(
"Could not deserialize '{self}' value as bool"
)))
}
}
| rust | Apache-2.0 | 2d3034ed73ba8d49e0f72251b4c7cfb859a1efe7 | 2026-01-04T20:24:59.602734Z | false |
openwallet-foundation/vcx | https://github.com/openwallet-foundation/vcx/blob/2d3034ed73ba8d49e0f72251b4c7cfb859a1efe7/aries/aries_vcx_anoncreds/src/utils/mod.rs | aries/aries_vcx_anoncreds/src/utils/mod.rs | pub mod constants;
pub mod json;
| rust | Apache-2.0 | 2d3034ed73ba8d49e0f72251b4c7cfb859a1efe7 | 2026-01-04T20:24:59.602734Z | false |
openwallet-foundation/vcx | https://github.com/openwallet-foundation/vcx/blob/2d3034ed73ba8d49e0f72251b4c7cfb859a1efe7/aries/aries_vcx_anoncreds/src/utils/constants.rs | aries/aries_vcx_anoncreds/src/utils/constants.rs | #![allow(dead_code)]
pub static ATTRS: &str = "attrs";
pub static LIBINDY_CRED_OFFER: &str = r#"{"issuer_did":"2hoqvcwupRTUNkXn6ArYzs","schema_key":{"name":"Home Address","version":"1.4","did":"2hoqvcwupRTUNkXn6ArYzs"},"key_correctness_proof":{"c":"8555253541554245344305351079388313043821365069629297255640200538622329722556","xz_cap":"64818256731588984794575029881576438712171978148821994354569423109505883511370051539530363090404289097908646608544866367046312481771587336183036163818849360474523320055058050733772575227932313793985470881830147160471852946598089626822740951538444260248405680001410943962258653118246973446307071417314391910474888369634752642195173997916292806072016186810315308257756689251031806948447462801785007243395079942815166817065271733596477143189406957903952991335446968764832960906258373699575234207180135806072152726528786138816315911998387303385565913657745597433033756984505440643451253917452841385494947936404135348354895376751800590086535707370194450915965147666804363452357419799188104044508109","xr_cap":{"address1":"8236425893392219787423825014385198460820517586004442204287421088285469674020926840448786131806503567730307555837801319715555107413533966776756997088003362401505821396887204933829958258785093075846810980429322007441122948459832086015057507926262051365966017173045228232337530339680355717180291794733363148324101203340879842496879728996183974739507710337122557429529832639384077022317326079678153237524335334790193774589523155338216849532635731123476861074950940938322358853287805286272076498390452028019829082291826739453475976800681550225322996208089503815975750152834370138410964418644082923687817510140143620366818252076463572791466640135793621279863114074326681043782582123182032344081138","address2":"30414471804770994051376437296525278254597585112268783700020054398847238843189530750793146903722533375657200785297557019465948393596156534191847866989266176618709331559949972729939131388887244366321127743968836991526071402029914419405781596054783690896660703606768577825229647587998380728894419570361864769440309185637967429191914824558483741394914212983254247799137730101941670911547714088499696084822272226072237693975774997990116374449197382931059877141968595755981160846810650806105803130004361523114137045586548743326078945833123588843296375692506658736851641735658969617721427932961073974202337608798761064528676757519926255271724266286989825397405029723387126754299497661658557574216867","city":"159795636056543233530021344623621334175753173834199599499234503024224170089287815725788337040803537786795901100564559891075793321268703839671526386175533087941057761454903389990043254221508542663884105491028667931433093528378567035675241504608287341705758154859625863922110474313370021277749973041267871971965548396722681397958408458464210449202419266126608057284371794186889175339171087558861231355840830361110708993602208821778313069364112399404445977187422249127909803315019664537899385297653020295835898441614009217452024854561288538496889400595485884757791655246945196819845725103196695608534259378231125159518322706097470964698852674734436475238855630473478573401236177640541599034507313","state":"215512468490315112938301657833926278136808116594771729699898320102646611321724434471863048390556908138905125523936043735201882025532772433002153410083708215401917118972375534193847316461794285777665177963351136804949997738950645361626956052973425101611071191598827068821964513860723502996877635652196651818308886110840798493982976675792164313480547213301748933952971154819253513296456319475340952940914757162158069252461973054465657233683514169036627218211903327888618365019366708902832859985119776192696909319524217085945724819529037625577237504453097885607411726308520123962852327787736505753002450290943635652415448032216336431217538662448209579828135627648861641446385394343199453905348086","zip":"238413810148929820131063264189691178282858328114757399256193590161266006646670344870416481980522447923115217342582281807424862378687793299109363839238237538377362459559820681904274866049652851183765153471969318096511161665533190643665261284892951569998678113101193901664492159340828270692168345719923300987213287650281559452357368956472066676438018575401605560388568884399190765464134955117933339552804676602790359330495723485338924295339609987825045590507344961620812843451249916254642836938597183261177212672766675968705705261108413829152581548433386403050115216912797280460237259161451733151284615735871654022007177671460429253488906111387740833557450384941388970535365310270275589048348152"}},"nonce":"45815185447169282124747"}"#;
pub static PROOF_REQUESTED_PREDICATES: &str = "requested_predicates";
pub static REQUESTED_ATTRIBUTES: &str = "requested_attributes";
pub static CREDENTIAL_REQ_STRING: &str = r#"{"libindy_cred_req":"{\"prover_did\":\"2hoqvcwupRTUNkXn6ArYzs\",\"cred_def_id\":\"2hoqvcwupRTUNkXn6ArYzs:3:CL:1766\",\"blinded_ms\":{\"u\":\"8732071602357015307810566138808197234658312581785137109788113302982640059349967050965447489217593298616209988826723701562661343443517589847218013366407845073616266391756009264980040238952349445643778936575656535779015458023493903785780518101975701982901383514030208868847307622362696880263163343848494510595690307613204277848599695882210459126941797459019913953592724097855109613611647709745072773427626720401442235193011557232562555622244156336806151662441234847773393387649719209243455960347563274791229126202016215550120934775060992031280966045894859557271641817491943416048075445449722000591059568013176905304195\",\"ur\":null},\"blinded_ms_correctness_proof\":{\"c\":\"26530740026507431379491385424781000855170637402280225419270466226736067904512\",\"v_dash_cap\":\"143142764256221649591394190756594263575252787336888260277569702754606119430149731374696604981582865909586330696038557351486556018124278706293019764236792379930773289730781387402321307275066512629558473696520197393762713894449968058415758200647216768004242460019909604733610794104180629190082978779757591726666340720737832809779281945323437475154340615798778337960748836468199407007775031657682302038533398039806427675709453395148841959462470861915712789403465722659960342165041260269463103782446132475688821810775202828210979373826636650138063942962121467854349698464501455098258293105554402435773328031261630390919907379686173528652481917022556931483089035786146580024468924714494948737711000361399753716101561779590\",\"ms_cap\":\"6713785684292289748157544902063599004332363811033155861083956757033688921010462943169460951559595511857618896433311745591610892377735569122165958960965808330552472093346163460366\"},\"nonce\":\"1154549882365416803296713\"}","libindy_cred_req_meta":"{\"master_secret_blinding_data\":{\"v_prime\":\"19573554835481719662327485122688893711456991477879921695470731620175963787279917341526369852398210114401207141951797741891847253211319668203346462590568438671120943726162783813341598838616013039004762423956877028539225355867586807673681018234178116101643797916210905197387018359780257940149589162122784199178788814187547780152684853122014747482921656188183260370150999742557975345375106137123621426061675848590309427394874048446416740808489978625893734432529086470382099078632291038405367083882596203500659091849643476443635802557200596085378755820180062431900445542883509174786917819553164472263849777903881905876531213020487201635195790520\",\"vr_prime\":null},\"nonce\":\"143213049816807095013964\",\"master_secret_name\":\"main\"}","cred_def_id":"2hoqvcwupRTUNkXn6ArYzs:3:CL:1766","tid":"cCanHnpFAD","to_did":"BnRXf8yDMUwGyZVDkSENeq","from_did":"GxtnGN6ypZYgEqcftSQFnC","version":"0.1","mid":"","msg_ref_id":"123"}"#;
pub static CREDENTIAL_JSON: &str = r#"{"claim": { "address1": [ "123 Main St", "67178325706055440519333844001910714778187200326224626679030947715618922270834" ], "address2": [ "Suite 3", "14069420537488782212572815457694763597282389356553685124587846316416790412172" ], "city": [ "Draper", "12909874379699016994385580221532801536154776321388073746338293599464917909913" ], "state": [ "UT", "93856629670657830351991220989031130499313559332549427637940645777813964461231" ], "zip": [ "84000", "84000" ] }, "claim_offer_id": "n2vlytr", "from_did": "A5zycNieiKQQU6xQTtR3ie", "issuer_did": "2hoqvcwupRTUNkXn6ArYzs", "msg_type": "CRED", "schema_seq_no": 22, "signature": { "non_revocation_claim": null, "primary_claim": { "a": "67244059587509386261445845549403679184696388188135088719570347990957702854576331330763123108600111867246898203893942330532414276708236493565050051577255278475231198777619682053425511310805374629000032369988817946046983751759949589692002588340296869187196574372221898903115017422604977611873108946802618066478041981199841837601172757327153617669273883040639649832266729961077172477776787709368285904991774256514200981595163262342626363217452242070410058562010319101992520148282733995635010533432768876074037878998373839551569333559642205700332716013642805666606069808481186570157152956520080458539520791159072055699608", "e": "259344723055062059907025491480697571938277889515152306249728583105665800713306759149981690559193987143012367913206299323899696942213235956742929979955970602668519234522036604952927", "m2": "73598276571237653510985065573388298358260861260139843942970542810506069131247", "v": "7782040862611754129906364472072177993242400915902838921150044188825385426320744155674271999800409192400475215606427400576174714844912910889635915209442760601639503812483333710498966677032266043782534729495630058139079759294540063522862433832217680399967662575805572449362848616899654527283911479159798692836920609447117694604550229460246691843256094252578966531478355690870011917944269894281735089639287126305305853350364136525483737759256221150059629492378671054376973353349516063810767461334097264068335988545196188611499359009325998360279987424407962189883068449914753466665140753744386975512941589134281298094791056350565149274890478146205610581609463698788908501060583315271304706101286351923769293430142774178612205047744806182681425621706093102973045356561983323064302333475988590139227392601738347814619853533067" } }, "version": "0.1" }"#;
pub const DID: &str = "FhrSrYtQcw3p9xwf7NYemf";
pub const VERKEY: &str = "91qMFrZjXDoi2Vc8Mm14Ys112tEZdDegBZZoembFEATE";
pub static PROOF_JSON: &str = r#"{"proof":{"proofs":[{"primary_proof":{"eq_proof":{"revealed_attrs":{"zip":"87121"},"a_prime":"11385117131660364111896731574172401420546708937324515452576064042574669257712348081839601624888211708194648786566821283532355289865761814401811668762111208667245892385556461650028028744704055636249982477585075400271187055151098908619974783653495410195833182515968533296209260588771695756312205872111048687853205561923237816546964283713422785468941977105067099251171604215251944317080214747243003427107934144216501594603687728398269433535428273623697427762663203253444115676455803364347007933198640450232624037803599295212149889810488912469008187381827942935958271186223675811120227514991467360019909918168868871310826","e":"106416440968489307688477111652744547884453520724896945262209396020249946843791285682305811237667052208528018943270519839389621717609114567","v":"693333598587517819941352847365742544380142765574139951146061816085618155189452020698413593997300585596324426252632314355582268506939303400407496417606249958981732261864957022478367092130677367027387866707732300909963513115315021003243992979679627258775140835220412197296938533762295871549731992640856382276196325998522049034267838563447330191852382971065392091768243880823490111370897368424139935395298937408562086499759656814447622881298133126653711399509169280794404022383866082757555249917245259236759269242823638516805150417229733278877402638802562166688388004908477637031034437462247846682697897200600573773942810246023809243280772183646809858924033191135463766964917504748987154189779729311869624825798007137022205256426446605413391018202025830072404371317952188965637832374449641811319605909172576074628353298939272848787572418960647922046317299399246159851863001665989283575050230911587927811099747218793149167944","m":{"address1":"14383563842714000336694832849665594946445962739184223209071037007452629790699757287294972813779623472744803572582328437911448950215408915191131611402522120804333222273489132084886","city":"6335807846068782600189687454462436112078812829004884052293133660597927372142081774735780601789659420890039727382522297770947316366004790684358611659096944452253560380208620107157","address2":"14091589660350349984354459530985480819537335363987179151561762220365706941537938554719525480994821015753311971694921036448081399741287968054078818802947721994040284668811562798267","state":"3374323397845656383843625203828356603754667474607034126894741033080120461511932284334653947059306129056440817463723283235350691497796837255669792651105389390523206636040269228223"},"m1":"3855360575146368990379338878340437444760062086797499842306857866860002517711237747809252335775444064433909759766687399940398272328893322787415703512272117087096813054972554563968","m2":"829849307958330576060854040909379039690330674646288918248299874016648994971333520820812771094141855582854026260700068274261655287053826960354567228953144532668188875028174450750"},"ge_proofs":[]},"non_revoc_proof":null},{"primary_proof":{"eq_proof":{"revealed_attrs":{"height":"25730877424947290072821310314181366395232879096832067784637233452620527354832"},"a_prime":"19606523040238141145717779531277522663224725021451964954928837778213780167806130611283656444876346090324217222925322088211429761142256636233006676888209824950866753616039040159779454392004510214888982466524158456130352445810766077072116343308981883033612830486699333857960241899822662839721374841002668163948377275672875472144246128931473522911282089521505706783701020863536724574924376299714351850171426752924728784363669376534908759391351622381020289812523865512890582404247961101220209552503431785599610046609564493669749669261122419593784559612666376852938604194178973814343952986182892452430023827671762557476463","e":"175708676962718808956603450728506825597108526784886396727551101010180796035520261116334855856024649318365254638362385900327196683643205289","v":"259807837216236716040272227118473612683891972149132456558837821820045873391789606085689340379415983105482747915525402053563208559407596040401913772550177102524653456118110816872909394038065296113425708018233090717854181564661116753447052574450590706580409613994542437680615027500439312381591222697969343626799892433263884943265734866198270469445076231573689904631155795742013664414011861042682562430778840652138660305373152231267819984539617728384058547342678165579739778850312059485316741860467804248135416832291520168882232179984203367316142165755286256284689566686572380792365871911853060464498285167571443335788402725298771375480014651263894303375604516169554253834245685148604580043733043610372908803488088857487861826680931152125459941500902596987258417619816375861312684684210554655250852226060290197739094390988802816264926238846473088662123137199115232833530286814846710257219453988118104609524238769962408378467","m":{"age":"7439137780003632501472198844883943985851982687398948370748383175062107337760437828394880407813732765383124554153414377359168765440779597987864714528157062929739375601687952057680","name":"478729181402353180485622154597836495776273289714890210090026576459958696376861534830836701841321719749324218544889558530446121758555251583232291309241803053682268055213713398699","sex":"3475750043210272427962584518900024357879025980293153402384602896340153685772192528112892451091903360990446424944281039234223910308784253682458410982729333916158905947811280570097"},"m1":"3855360575146368990379338878340437444760062086797499842306857866860002517711237747809252335775444064433909759766687399940398272328893322787415703512272117087096813054972554563968","m2":"11250551913673338582984048217906733348080383121220187035974642609915309422920937161820959912087373627684234183422675877388269370474604625896553325837450381771318770783786394439756"},"ge_proofs":[]},"non_revoc_proof":null}],"aggregated_proof":{"c_hash":"98289858372176739486785426465663295860443703464650074572637147012182597972573","c_list":[[90,48,0,0,86,54,61,179,29,65,240,170,216,13,100,217,170,179,191,79,71,2,133,94,84,120,87,90,167,161,166,221,56,137,73,156,8,139,61,114,10,131,241,112,150,110,102,170,132,231,229,250,177,131,6,33,158,228,233,190,125,211,244,238,143,232,12,25,154,52,34,54,194,237,16,20,239,207,37,3,211,34,39,70,253,226,25,2,235,164,40,227,87,103,108,40,93,125,174,74,139,95,111,175,124,1,26,204,120,172,3,125,18,149,107,209,82,168,46,185,96,173,161,80,33,165,32,40,166,106,141,41,55,143,50,219,37,210,114,90,104,64,249,193,195,157,51,34,174,127,83,251,254,102,199,221,199,239,204,13,221,216,8,254,107,100,14,31,49,38,187,243,247,12,116,110,169,98,85,202,127,237,149,126,10,115,200,229,74,131,202,195,188,176,253,132,25,117,104,197,73,252,211,192,235,136,7,83,136,235,152,98,99,208,232,50,165,117,245,89,138,255,143,241,113,14,130,94,125,253,252,74,45,73,67,49,87,12,106,218,197,238,82,134,231,210,33,228,189,181,71,168,252,217,141,234],[155,80,70,194,115,251,48,64,107,148,172,180,25,185,82,75,129,60,47,228,47,102,33,64,158,83,190,172,149,37,66,189,237,26,120,207,50,163,29,130,142,226,11,83,96,172,63,161,188,131,75,138,14,180,56,139,244,111,163,136,89,239,13,161,204,20,204,227,236,219,156,33,217,141,114,76,47,221,129,186,123,46,16,6,158,238,205,66,208,252,108,184,252,72,229,52,89,54,68,23,39,130,57,231,96,236,130,157,65,41,42,21,8,247,206,179,36,244,164,132,158,56,191,73,212,192,234,95,143,141,194,71,197,58,172,122,170,220,53,59,64,201,234,28,74,198,125,206,10,240,192,145,14,207,68,227,132,185,85,112,173,156,71,73,80,60,152,100,252,45,249,201,153,5,159,61,27,105,97,57,61,35,233,190,23,158,46,141,42,41,225,141,26,41,123,60,243,10,81,251,234,32,192,181,135,122,167,231,106,8,123,92,196,197,191,104,119,235,205,181,178,62,248,146,71,221,250,251,193,217,14,213,13,121,37,76,209,150,22,216,155,84,212,58,58,38,148,170,178,86,185,107,84,152,30,111]]}},"requested_proof":{"revealed_attrs":{"zip_2":{"sub_proof_index":0,"raw":"87121","encoded":"87121"},"height_1":{"sub_proof_index":1,"raw":"4'11","encoded":"25730877424947290072821310314181366395232879096832067784637233452620527354832"}},"self_attested_attrs":{"self_attest_3":"my_self_attested_val"},"unrevealed_attrs":{},"predicates":{}},"identifiers":[{"schema_id":"2hoqvcwupRTUNkXn6ArYzs:2:Home Address:5.5.5","cred_def_id":"2hoqvcwupRTUNkXn6ArYzs:3:CL:2479","rev_reg_id":null,"timestamp":null},{"schema_id":"2hoqvcwupRTUNkXn6ArYzs:2:test-licence:4.4.4","cred_def_id":"2hoqvcwupRTUNkXn6ArYzs:3:CL:2471","rev_reg_id":null,"timestamp":null}]}"#;
pub static REV_STATE_JSON: &str = r#"{"V4SGRU86Z58d6TV7PBUe6f:4:V4SGRU86Z58d6TV7PBUe6f:3:CL:744:tag1:CL_ACCUM:tag1":{"1540930249":{"rev_reg":{"accum":"1 0000000000000000000000000000000000000000000000000000000000000000 1 0000000000000000000000000000000000000000000000000000000000000000 2 095E45DDF417D05FB10933FFC63D474548B7FFFF7888802F07FFFFFF7D07A8A8 1 0000000000000000000000000000000000000000000000000000000000000000 1 0000000000000000000000000000000000000000000000000000000000000000 1 0000000000000000000000000000000000000000000000000000000000000000"},"timestamp":100,"witness":{"omega":"1 0000000000000000000000000000000000000000000000000000000000000000 1 0000000000000000000000000000000000000000000000000000000000000000 2 095E45DDF417D05FB10933FFC63D474548B7FFFF7888802F07FFFFFF7D07A8A8 1 0000000000000000000000000000000000000000000000000000000000000000 1 0000000000000000000000000000000000000000000000000000000000000000 1 0000000000000000000000000000000000000000000000000000000000000000"}}}}"#;
| rust | Apache-2.0 | 2d3034ed73ba8d49e0f72251b4c7cfb859a1efe7 | 2026-01-04T20:24:59.602734Z | false |
openwallet-foundation/vcx | https://github.com/openwallet-foundation/vcx/blob/2d3034ed73ba8d49e0f72251b4c7cfb859a1efe7/aries/aries_vcx_anoncreds/src/anoncreds/base_anoncreds.rs | aries/aries_vcx_anoncreds/src/anoncreds/base_anoncreds.rs | use std::{collections::HashMap, path::Path};
use anoncreds_types::data_types::{
identifiers::{
cred_def_id::CredentialDefinitionId, rev_reg_def_id::RevocationRegistryDefinitionId,
schema_id::SchemaId,
},
ledger::{
cred_def::CredentialDefinition,
rev_reg::RevocationRegistry,
rev_reg_def::RevocationRegistryDefinition,
rev_reg_delta::RevocationRegistryDelta,
rev_status_list::RevocationStatusList,
schema::{AttributeNames, Schema},
},
messages::{
cred_definition_config::CredentialDefinitionConfig,
cred_offer::CredentialOffer,
cred_request::{CredentialRequest, CredentialRequestMetadata},
cred_selection::{RetrievedCredentialInfo, RetrievedCredentials},
credential::{Credential, CredentialValues},
nonce::Nonce,
pres_request::PresentationRequest,
presentation::{Presentation, RequestedCredentials},
revocation_state::CredentialRevocationState,
},
};
use aries_vcx_wallet::wallet::base_wallet::BaseWallet;
use async_trait::async_trait;
use did_parser_nom::Did;
use crate::errors::error::VcxAnoncredsResult;
pub type CredentialId = String;
pub type LinkSecretId = String;
pub type SchemasMap = HashMap<SchemaId, Schema>;
pub type CredentialDefinitionsMap = HashMap<CredentialDefinitionId, CredentialDefinition>;
pub type RevocationStatesMap = HashMap<String, HashMap<u64, CredentialRevocationState>>;
pub type RevocationRegistryDefinitionsMap =
HashMap<RevocationRegistryDefinitionId, RevocationRegistryDefinition>;
pub type RevocationRegistriesMap =
HashMap<RevocationRegistryDefinitionId, HashMap<u64, RevocationRegistry>>;
/// Trait defining standard 'anoncreds' related functionality. The APIs, including
/// input and output types are based off the indy Anoncreds API:
/// see: <https://github.com/hyperledger/indy-sdk/blob/main/libindy/src/api/anoncreds.rs>
#[async_trait]
pub trait BaseAnonCreds: std::fmt::Debug + Send + Sync {
async fn verifier_verify_proof(
&self,
proof_request_json: PresentationRequest,
proof_json: Presentation,
schemas_json: SchemasMap,
credential_defs_json: CredentialDefinitionsMap,
rev_reg_defs_json: Option<RevocationRegistryDefinitionsMap>,
rev_regs_json: Option<RevocationRegistriesMap>,
) -> VcxAnoncredsResult<bool>;
async fn issuer_create_and_store_revoc_reg(
&self,
wallet: &impl BaseWallet,
issuer_did: &Did,
cred_def_id: &CredentialDefinitionId,
tails_dir: &Path,
max_creds: u32,
tag: &str,
) -> VcxAnoncredsResult<(
RevocationRegistryDefinitionId,
RevocationRegistryDefinition,
RevocationRegistry,
)>;
#[allow(clippy::too_many_arguments)]
async fn issuer_create_and_store_credential_def(
&self,
wallet: &impl BaseWallet,
issuer_did: &Did,
schema_id: &SchemaId,
schema_json: Schema,
config_json: CredentialDefinitionConfig,
) -> VcxAnoncredsResult<CredentialDefinition>;
async fn issuer_create_credential_offer(
&self,
wallet: &impl BaseWallet,
cred_def_id: &CredentialDefinitionId,
) -> VcxAnoncredsResult<CredentialOffer>;
async fn issuer_create_credential(
&self,
wallet: &impl BaseWallet,
cred_offer_json: CredentialOffer,
cred_req_json: CredentialRequest,
cred_values_json: CredentialValues,
rev_reg_id: Option<&RevocationRegistryDefinitionId>,
tails_dir: Option<&Path>,
) -> VcxAnoncredsResult<(Credential, Option<u32>)>;
#[allow(clippy::too_many_arguments)]
async fn prover_create_proof(
&self,
wallet: &impl BaseWallet,
proof_req_json: PresentationRequest,
requested_credentials_json: RequestedCredentials,
link_secret_id: &LinkSecretId,
schemas_json: SchemasMap,
credential_defs_json: CredentialDefinitionsMap,
revoc_states_json: Option<RevocationStatesMap>,
) -> VcxAnoncredsResult<Presentation>;
async fn prover_get_credential(
&self,
wallet: &impl BaseWallet,
cred_id: &CredentialId,
) -> VcxAnoncredsResult<RetrievedCredentialInfo>;
async fn prover_get_credentials(
&self,
wallet: &impl BaseWallet,
filter_json: Option<&str>,
) -> VcxAnoncredsResult<Vec<RetrievedCredentialInfo>>;
async fn prover_get_credentials_for_proof_req(
&self,
wallet: &impl BaseWallet,
proof_request_json: PresentationRequest,
) -> VcxAnoncredsResult<RetrievedCredentials>;
async fn prover_create_credential_req(
&self,
wallet: &impl BaseWallet,
prover_did: &Did,
cred_offer_json: CredentialOffer,
cred_def_json: CredentialDefinition,
link_secret_id: &LinkSecretId,
) -> VcxAnoncredsResult<(CredentialRequest, CredentialRequestMetadata)>;
async fn create_revocation_state(
&self,
tails_dir: &Path,
rev_reg_def_json: RevocationRegistryDefinition,
rev_status_list: RevocationStatusList,
cred_rev_id: u32,
) -> VcxAnoncredsResult<CredentialRevocationState>;
async fn prover_store_credential(
&self,
wallet: &impl BaseWallet,
cred_req_metadata: CredentialRequestMetadata,
unprocessed_cred: Credential,
schema: Schema,
cred_def: CredentialDefinition,
rev_reg_def: Option<RevocationRegistryDefinition>,
) -> VcxAnoncredsResult<CredentialId>;
async fn prover_delete_credential(
&self,
wallet: &impl BaseWallet,
cred_id: &CredentialId,
) -> VcxAnoncredsResult<()>;
async fn prover_create_link_secret(
&self,
wallet: &impl BaseWallet,
link_secret_id: &LinkSecretId,
) -> VcxAnoncredsResult<()>;
async fn issuer_create_schema(
&self,
issuer_did: &Did,
name: &str,
version: &str,
attrs: AttributeNames,
) -> VcxAnoncredsResult<Schema>;
// TODO - FUTURE - think about moving this to somewhere else, as it aggregates other calls (not
// PURE Anoncreds)
// ^ YES
// TODO - review functionality below and convert to using statuslists (https://github.com/openwallet-foundation/vcx/issues/1309)
async fn revoke_credential_local(
&self,
wallet: &impl BaseWallet,
rev_reg_id: &RevocationRegistryDefinitionId,
cred_rev_id: u32,
rev_reg_delta_json: RevocationRegistryDelta,
) -> VcxAnoncredsResult<()>;
async fn get_rev_reg_delta(
&self,
wallet: &impl BaseWallet,
rev_reg_id: &RevocationRegistryDefinitionId,
) -> VcxAnoncredsResult<Option<RevocationRegistryDelta>>;
async fn clear_rev_reg_delta(
&self,
wallet: &impl BaseWallet,
rev_reg_id: &RevocationRegistryDefinitionId,
) -> VcxAnoncredsResult<()>;
async fn generate_nonce(&self) -> VcxAnoncredsResult<Nonce>;
}
| rust | Apache-2.0 | 2d3034ed73ba8d49e0f72251b4c7cfb859a1efe7 | 2026-01-04T20:24:59.602734Z | false |
openwallet-foundation/vcx | https://github.com/openwallet-foundation/vcx/blob/2d3034ed73ba8d49e0f72251b4c7cfb859a1efe7/aries/aries_vcx_anoncreds/src/anoncreds/mod.rs | aries/aries_vcx_anoncreds/src/anoncreds/mod.rs | #[allow(clippy::module_inception)]
#[cfg(feature = "anoncreds")]
pub mod anoncreds;
pub mod base_anoncreds;
| rust | Apache-2.0 | 2d3034ed73ba8d49e0f72251b4c7cfb859a1efe7 | 2026-01-04T20:24:59.602734Z | false |
openwallet-foundation/vcx | https://github.com/openwallet-foundation/vcx/blob/2d3034ed73ba8d49e0f72251b4c7cfb859a1efe7/aries/aries_vcx_anoncreds/src/anoncreds/anoncreds/type_conversion.rs | aries/aries_vcx_anoncreds/src/anoncreds/anoncreds/type_conversion.rs | use std::collections::HashMap;
use anoncreds::{
cl::RevocationRegistry as CryptoRevocationRegistry,
data_types::{
cred_def::{
CredentialDefinition as AnoncredsCredentialDefinition,
CredentialDefinitionData as AnoncredsCredentialDefinitionData,
CredentialDefinitionId as AnoncredsCredentialDefinitionId,
},
issuer_id::IssuerId as AnoncredsIssuerId,
nonce::Nonce as AnoncredsNonce,
rev_reg_def::{
RevocationRegistryDefinitionId as AnoncredsRevocationRegistryDefinitionId,
RevocationRegistryDefinitionValue as AnoncredsRevocationRegistryDefinitionValue,
},
schema::{Schema as AnoncredsSchema, SchemaId as AnoncredsSchemaId},
},
types::{
AttributeNames as AnoncredsAttributeNames, Credential as AnoncredsCredential,
CredentialDefinitionConfig as AnoncredsCredentialDefinitionConfig,
CredentialOffer as AnoncredsCredentialOffer,
CredentialRequest as AnoncredsCredentialRequest,
CredentialRequestMetadata as AnoncredsCredentialRequestMetadata,
CredentialRevocationState as AnoncredsCredentialRevocationState,
CredentialValues as AnoncredsCredentialValues, Presentation as AnoncredsPresentation,
PresentationRequest as AnoncredsPresentationRequest,
RevocationRegistry as AnoncredsRevocationRegistry,
RevocationRegistryDefinition as AnoncredsRevocationRegistryDefinition,
RevocationStatusList as AnoncredsRevocationStatusList,
SignatureType as AnoncredsSignatureType,
},
};
use anoncreds_types::data_types::{
identifiers::{
cred_def_id::CredentialDefinitionId as OurCredentialDefinitionId,
issuer_id::IssuerId as OurIssuerId,
rev_reg_def_id::RevocationRegistryDefinitionId as OurRevocationRegistryDefinitionId,
schema_id::SchemaId as OurSchemaId,
},
ledger::{
cred_def::{
CredentialDefinition as OurCredentialDefinition,
CredentialDefinitionData as OurCredentialDefinitionData,
SignatureType as OurSignatureType,
},
rev_reg::RevocationRegistry as OurRevocationRegistry,
rev_reg_def::{
RevocationRegistryDefinition as OurRevocationRegistryDefinition,
RevocationRegistryDefinitionValue as OurRevocationRegistryDefinitionValue,
},
rev_status_list::RevocationStatusList as OurRevocationStatusList,
schema::{AttributeNames as OurAttributeNames, Schema as OurSchema},
},
messages::{
cred_definition_config::CredentialDefinitionConfig as OurCredentialDefinitionConfig,
cred_offer::CredentialOffer as OurCredentialOffer,
cred_request::{
CredentialRequest as OurCredentialRequest,
CredentialRequestMetadata as OurCredentialRequestMetadata,
},
credential::{Credential as OurCredential, CredentialValues as OurCredentialValues},
nonce::Nonce as OurNonce,
pres_request::PresentationRequest as OurPresentationRequest,
presentation::Presentation as OurPresentation,
revocation_state::CredentialRevocationState as OurCredentialRevocationState,
},
};
pub trait Convert {
type Args;
type Target;
type Error;
fn convert(self, args: Self::Args) -> Result<Self::Target, Self::Error>;
}
impl Convert for OurIssuerId {
type Args = ();
type Target = AnoncredsIssuerId;
type Error = Box<dyn std::error::Error>;
fn convert(self, _args: Self::Args) -> Result<Self::Target, Self::Error> {
AnoncredsIssuerId::new(self.to_string()).map_err(|e| e.into())
}
}
fn serde_convert<S, T>(arg: T) -> Result<S, Box<dyn std::error::Error>>
where
S: serde::Serialize + serde::de::DeserializeOwned,
T: serde::Serialize + serde::de::DeserializeOwned,
{
Ok(serde_json::from_value(serde_json::to_value(arg)?)?)
}
impl Convert for AnoncredsIssuerId {
type Args = ();
type Target = OurIssuerId;
type Error = Box<dyn std::error::Error>;
fn convert(self, _args: Self::Args) -> Result<Self::Target, Self::Error> {
OurIssuerId::new(self.to_string()).map_err(|e| e.into())
}
}
impl Convert for OurAttributeNames {
type Args = ();
type Target = AnoncredsAttributeNames;
type Error = Box<dyn std::error::Error>;
fn convert(self, _args: Self::Args) -> Result<Self::Target, Self::Error> {
Ok(AnoncredsAttributeNames(self.0))
}
}
impl Convert for AnoncredsAttributeNames {
type Args = ();
type Target = OurAttributeNames;
type Error = Box<dyn std::error::Error>;
fn convert(self, _args: Self::Args) -> Result<Self::Target, Self::Error> {
Ok(OurAttributeNames(self.0))
}
}
impl Convert for OurSchema {
type Args = ();
type Target = AnoncredsSchema;
type Error = Box<dyn std::error::Error>;
fn convert(self, _: Self::Args) -> Result<Self::Target, Self::Error> {
Ok(AnoncredsSchema {
name: self.name,
version: self.version,
attr_names: self.attr_names.convert(())?,
issuer_id: self.issuer_id.convert(())?,
})
}
}
impl Convert for AnoncredsSchema {
type Args = (String,);
type Target = OurSchema;
type Error = Box<dyn std::error::Error>;
fn convert(self, (schema_id,): Self::Args) -> Result<Self::Target, Self::Error> {
Ok(OurSchema {
id: OurSchemaId::new(schema_id)?,
seq_no: None,
name: self.name,
version: self.version,
attr_names: self.attr_names.convert(())?,
issuer_id: self.issuer_id.convert(())?,
})
}
}
impl Convert for OurCredentialDefinitionConfig {
type Args = ();
type Target = AnoncredsCredentialDefinitionConfig;
type Error = Box<dyn std::error::Error>;
fn convert(self, _args: Self::Args) -> Result<Self::Target, Self::Error> {
Ok(AnoncredsCredentialDefinitionConfig {
support_revocation: self.support_revocation,
})
}
}
impl Convert for OurSignatureType {
type Args = ();
type Target = AnoncredsSignatureType;
type Error = Box<dyn std::error::Error>;
fn convert(self, _args: Self::Args) -> Result<Self::Target, Self::Error> {
match self {
OurSignatureType::CL => Ok(AnoncredsSignatureType::CL),
}
}
}
impl Convert for AnoncredsSignatureType {
type Args = ();
type Target = OurSignatureType;
type Error = Box<dyn std::error::Error>;
fn convert(self, _args: Self::Args) -> Result<Self::Target, Self::Error> {
match self {
AnoncredsSignatureType::CL => Ok(OurSignatureType::CL),
}
}
}
impl Convert for AnoncredsCredentialDefinition {
type Args = (String,);
type Target = OurCredentialDefinition;
type Error = Box<dyn std::error::Error>;
fn convert(self, (cred_def_id,): Self::Args) -> Result<Self::Target, Self::Error> {
Ok(OurCredentialDefinition {
id: OurCredentialDefinitionId::new(cred_def_id)?,
schema_id: OurSchemaId::new_unchecked(self.schema_id.to_string()),
signature_type: self.signature_type.convert(())?,
tag: self.tag,
value: OurCredentialDefinitionData {
primary: self.value.primary,
revocation: self.value.revocation,
},
issuer_id: OurIssuerId::new(self.issuer_id.to_string())?,
})
}
}
impl Convert for OurCredentialDefinition {
type Args = ();
type Target = AnoncredsCredentialDefinition;
type Error = Box<dyn std::error::Error>;
fn convert(self, (): Self::Args) -> Result<Self::Target, Self::Error> {
Ok(AnoncredsCredentialDefinition {
schema_id: AnoncredsSchemaId::new_unchecked(self.schema_id.to_string()),
signature_type: self.signature_type.convert(())?,
tag: self.tag,
value: AnoncredsCredentialDefinitionData {
primary: self.value.primary,
revocation: self.value.revocation,
},
issuer_id: self.issuer_id.convert(())?,
})
}
}
impl Convert for anoncreds::types::RegistryType {
type Args = ();
type Target = anoncreds_types::data_types::ledger::rev_reg_def::RegistryType;
type Error = Box<dyn std::error::Error>;
fn convert(self, (): Self::Args) -> Result<Self::Target, Self::Error> {
Ok(match self {
anoncreds::types::RegistryType::CL_ACCUM => {
anoncreds_types::data_types::ledger::rev_reg_def::RegistryType::CL_ACCUM
}
})
}
}
impl Convert for anoncreds_types::data_types::ledger::rev_reg_def::RegistryType {
type Args = ();
type Target = anoncreds::types::RegistryType;
type Error = Box<dyn std::error::Error>;
fn convert(self, (): Self::Args) -> Result<Self::Target, Self::Error> {
Ok(match self {
anoncreds_types::data_types::ledger::rev_reg_def::RegistryType::CL_ACCUM => {
anoncreds::types::RegistryType::CL_ACCUM
}
})
}
}
impl Convert for OurRevocationRegistryDefinition {
type Args = ();
type Target = AnoncredsRevocationRegistryDefinition;
type Error = Box<dyn std::error::Error>;
fn convert(self, (): Self::Args) -> Result<Self::Target, Self::Error> {
Ok(AnoncredsRevocationRegistryDefinition {
issuer_id: self.issuer_id.convert(())?,
revoc_def_type: self.revoc_def_type.convert(())?,
tag: self.tag,
cred_def_id: AnoncredsCredentialDefinitionId::new(self.cred_def_id.to_string())?,
value: AnoncredsRevocationRegistryDefinitionValue {
max_cred_num: self.value.max_cred_num,
public_keys: serde_convert(self.value.public_keys)?,
tails_hash: self.value.tails_hash,
tails_location: self.value.tails_location,
},
})
}
}
impl Convert for AnoncredsRevocationRegistryDefinition {
type Args = (String,);
type Target = OurRevocationRegistryDefinition;
type Error = Box<dyn std::error::Error>;
fn convert(self, (rev_reg_def_id,): Self::Args) -> Result<Self::Target, Self::Error> {
Ok(OurRevocationRegistryDefinition {
id: OurRevocationRegistryDefinitionId::new(rev_reg_def_id)?,
issuer_id: self.issuer_id.convert(())?,
revoc_def_type: self.revoc_def_type.convert(())?,
tag: self.tag,
cred_def_id: OurCredentialDefinitionId::new(self.cred_def_id.to_string())?,
value: OurRevocationRegistryDefinitionValue {
max_cred_num: self.value.max_cred_num,
public_keys: serde_convert(self.value.public_keys)?,
tails_hash: self.value.tails_hash,
tails_location: self.value.tails_location,
},
})
}
}
impl Convert for AnoncredsRevocationRegistry {
type Args = ();
type Target = OurRevocationRegistry;
type Error = Box<dyn std::error::Error>;
fn convert(self, (): Self::Args) -> Result<Self::Target, Self::Error> {
Ok(OurRevocationRegistry {
value: serde_convert(self.value)?,
})
}
}
impl Convert for AnoncredsNonce {
type Args = ();
type Target = OurNonce;
type Error = Box<dyn std::error::Error>;
fn convert(self, (): Self::Args) -> Result<Self::Target, Self::Error> {
Ok(OurNonce::from_native(self.into_native()).unwrap())
}
}
impl Convert for OurCredentialRequest {
type Args = ();
type Target = AnoncredsCredentialRequest;
type Error = Box<dyn std::error::Error>;
fn convert(self, (): Self::Args) -> Result<Self::Target, Self::Error> {
serde_convert(self)
}
}
impl Convert for AnoncredsCredentialRequest {
type Args = ();
type Target = OurCredentialRequest;
type Error = Box<dyn std::error::Error>;
fn convert(self, (): Self::Args) -> Result<Self::Target, Self::Error> {
serde_convert(self)
}
}
impl Convert for OurCredentialRequestMetadata {
type Args = ();
type Target = AnoncredsCredentialRequestMetadata;
type Error = Box<dyn std::error::Error>;
fn convert(self, (): Self::Args) -> Result<Self::Target, Self::Error> {
serde_convert(self)
}
}
impl Convert for AnoncredsCredentialRequestMetadata {
type Args = ();
type Target = OurCredentialRequestMetadata;
type Error = Box<dyn std::error::Error>;
fn convert(self, (): Self::Args) -> Result<Self::Target, Self::Error> {
serde_convert(self)
}
}
impl Convert for OurCredentialOffer {
type Args = ();
type Target = AnoncredsCredentialOffer;
type Error = Box<dyn std::error::Error>;
fn convert(self, (): Self::Args) -> Result<Self::Target, Self::Error> {
serde_convert(self)
}
}
impl Convert for AnoncredsCredentialOffer {
type Args = ();
type Target = OurCredentialOffer;
type Error = Box<dyn std::error::Error>;
fn convert(self, (): Self::Args) -> Result<Self::Target, Self::Error> {
serde_convert(self)
}
}
impl Convert for OurCredential {
type Args = ();
type Target = AnoncredsCredential;
type Error = Box<dyn std::error::Error>;
fn convert(self, _args: Self::Args) -> Result<Self::Target, Self::Error> {
Ok(AnoncredsCredential {
schema_id: AnoncredsSchemaId::try_from(self.schema_id.to_string())?,
cred_def_id: AnoncredsCredentialDefinitionId::try_from(self.cred_def_id.to_string())?,
rev_reg_id: self
.rev_reg_id
.as_ref()
.map(ToString::to_string)
.map(AnoncredsRevocationRegistryDefinitionId::try_from)
.transpose()?,
values: serde_convert(self.values)?,
signature: serde_convert(self.signature)?,
signature_correctness_proof: serde_convert(self.signature_correctness_proof)?,
rev_reg: serde_convert(self.rev_reg)?,
witness: serde_convert(self.witness)?,
})
}
}
impl Convert for AnoncredsCredential {
type Args = ();
type Target = OurCredential;
type Error = Box<dyn std::error::Error>;
fn convert(self, _args: Self::Args) -> Result<Self::Target, Self::Error> {
Ok(OurCredential {
schema_id: OurSchemaId::new_unchecked(self.schema_id.to_string()),
cred_def_id: OurCredentialDefinitionId::new(self.cred_def_id.to_string())?,
rev_reg_id: self
.rev_reg_id
.as_ref()
.map(ToString::to_string)
.map(OurRevocationRegistryDefinitionId::new)
.transpose()?,
values: serde_convert(self.values)?,
signature: serde_convert(self.signature)?,
signature_correctness_proof: serde_convert(self.signature_correctness_proof)?,
rev_reg: serde_convert(self.rev_reg)?,
witness: serde_convert(self.witness)?,
})
}
}
impl Convert for HashMap<OurSchemaId, OurSchema> {
type Args = ();
type Target = HashMap<AnoncredsSchemaId, AnoncredsSchema>;
type Error = Box<dyn std::error::Error>;
fn convert(self, (): Self::Args) -> Result<Self::Target, Self::Error> {
self.into_iter()
.map(|(id, schema)| {
Ok((
AnoncredsSchemaId::try_from(id.to_string())?,
schema.convert(())?,
))
})
.collect()
}
}
impl Convert for HashMap<OurCredentialDefinitionId, OurCredentialDefinition> {
type Args = ();
type Target = HashMap<AnoncredsCredentialDefinitionId, AnoncredsCredentialDefinition>;
type Error = Box<dyn std::error::Error>;
fn convert(self, (): Self::Args) -> Result<Self::Target, Self::Error> {
self.into_iter()
.map(|(id, def)| {
Ok((
AnoncredsCredentialDefinitionId::try_from(id.to_string())?,
def.convert(())?,
))
})
.collect()
}
}
impl Convert for HashMap<OurRevocationRegistryDefinitionId, OurRevocationRegistryDefinition> {
type Args = ();
type Target =
HashMap<AnoncredsRevocationRegistryDefinitionId, AnoncredsRevocationRegistryDefinition>;
type Error = Box<dyn std::error::Error>;
fn convert(self, (): Self::Args) -> Result<Self::Target, Self::Error> {
self.into_iter()
.map(|(id, def)| {
Ok((
AnoncredsRevocationRegistryDefinitionId::try_from(id.to_string())?,
def.convert(())?,
))
})
.collect()
}
}
impl Convert
for HashMap<
OurRevocationRegistryDefinitionId,
(HashMap<u64, OurRevocationRegistry>, OurIssuerId),
>
{
type Args = ();
type Target = Vec<AnoncredsRevocationStatusList>;
type Error = Box<dyn std::error::Error>;
fn convert(self, _args: Self::Args) -> Result<Self::Target, Self::Error> {
let mut lists = Vec::new();
for (rev_reg_def_id, (timestamp_map, issuer_id)) in self.into_iter() {
for (timestamp, entry) in timestamp_map {
let OurRevocationRegistry { value } = entry;
let registry = CryptoRevocationRegistry { accum: value.accum };
let rev_status_list = OurRevocationStatusList::new(
Some(&rev_reg_def_id.to_string()),
issuer_id.clone(),
Default::default(),
Some(registry),
Some(timestamp),
)?;
lists.push(rev_status_list.convert(())?);
}
}
Ok(lists)
}
}
impl Convert for OurPresentationRequest {
type Args = ();
type Target = AnoncredsPresentationRequest;
type Error = Box<dyn std::error::Error>;
fn convert(self, _args: Self::Args) -> Result<Self::Target, Self::Error> {
serde_convert(self)
}
}
impl Convert for OurPresentation {
type Args = ();
type Target = AnoncredsPresentation;
type Error = Box<dyn std::error::Error>;
fn convert(self, _args: Self::Args) -> Result<Self::Target, Self::Error> {
serde_convert(self)
}
}
impl Convert for AnoncredsPresentation {
type Args = ();
type Target = OurPresentation;
type Error = Box<dyn std::error::Error>;
fn convert(self, _args: Self::Args) -> Result<Self::Target, Self::Error> {
serde_convert(self)
}
}
impl Convert for OurCredentialValues {
type Args = ();
type Target = AnoncredsCredentialValues;
type Error = Box<dyn std::error::Error>;
fn convert(self, _args: Self::Args) -> Result<Self::Target, Self::Error> {
serde_convert(self)
}
}
impl Convert for AnoncredsCredentialRevocationState {
type Args = ();
type Target = OurCredentialRevocationState;
type Error = Box<dyn std::error::Error>;
fn convert(self, _args: Self::Args) -> Result<Self::Target, Self::Error> {
serde_convert(self)
}
}
impl Convert for OurCredentialRevocationState {
type Args = ();
type Target = AnoncredsCredentialRevocationState;
type Error = Box<dyn std::error::Error>;
fn convert(self, _args: Self::Args) -> Result<Self::Target, Self::Error> {
serde_convert(self)
}
}
impl Convert for AnoncredsRevocationStatusList {
type Args = ();
type Target = OurRevocationStatusList;
type Error = Box<dyn std::error::Error>;
fn convert(self, _: Self::Args) -> Result<Self::Target, Self::Error> {
serde_convert(self)
}
}
impl Convert for OurRevocationStatusList {
type Args = ();
type Target = AnoncredsRevocationStatusList;
type Error = Box<dyn std::error::Error>;
fn convert(self, _: Self::Args) -> Result<Self::Target, Self::Error> {
serde_convert(self)
}
}
| rust | Apache-2.0 | 2d3034ed73ba8d49e0f72251b4c7cfb859a1efe7 | 2026-01-04T20:24:59.602734Z | false |
openwallet-foundation/vcx | https://github.com/openwallet-foundation/vcx/blob/2d3034ed73ba8d49e0f72251b4c7cfb859a1efe7/aries/aries_vcx_anoncreds/src/anoncreds/anoncreds/mod.rs | aries/aries_vcx_anoncreds/src/anoncreds/anoncreds/mod.rs | mod type_conversion;
use std::{
collections::{HashMap, HashSet},
path::Path,
};
use anoncreds::{
cl::{Accumulator, RevocationRegistry as CryptoRevocationRegistry},
data_types::{
cred_def::{
CredentialDefinition as AnoncredsCredentialDefinition,
CredentialDefinitionId as AnoncredsCredentialDefinitionId, CL_SIGNATURE_TYPE,
},
credential::Credential as AnoncredsCredential,
issuer_id::IssuerId,
rev_reg_def::{
RevocationRegistryDefinitionId as AnoncredsRevocationRegistryDefinitionId, CL_ACCUM,
},
schema::{Schema as AnoncredsSchema, SchemaId as AnoncredsSchemaId},
},
issuer::{create_revocation_registry_def, create_revocation_status_list},
tails::TailsFileWriter,
types::{
CredentialOffer as AnoncredsCredentialOffer,
CredentialRequest as AnoncredsCredentialRequest,
CredentialRequestMetadata as AnoncredsCredentialRequestMetadata,
CredentialRevocationConfig,
CredentialRevocationState as AnoncredsCredentialRevocationState,
CredentialValues as AnoncredsCredentialValues, LinkSecret, PresentCredentials,
Presentation as AnoncredsPresentation, PresentationRequest as AnoncredsPresentationRequest,
RegistryType, RevocationRegistry as AnoncredsRevocationRegistry,
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,
},
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 did_parser_nom::Did;
use log::warn;
use serde::{de::DeserializeOwned, Deserialize, Serialize};
use serde_json::{json, Value};
use time::OffsetDateTime;
use uuid::Uuid;
use super::base_anoncreds::{
BaseAnonCreds, CredentialDefinitionsMap, CredentialId, LinkSecretId, RevocationRegistriesMap,
RevocationRegistryDefinitionsMap, RevocationStatesMap, SchemasMap,
};
use crate::{
anoncreds::anoncreds::type_conversion::Convert,
errors::error::{VcxAnoncredsError, VcxAnoncredsResult},
};
fn from_revocation_status_list_to_revocation_registry_delta(
rev_status_list: &RevocationStatusList,
prev_accum: Option<Accumulator>,
) -> VcxAnoncredsResult<RevocationRegistryDelta> {
let _issued = rev_status_list
.state()
.iter()
.enumerate()
.filter_map(
|(idx, is_revoked)| {
if !is_revoked {
Some(idx as u32)
} else {
None
}
},
)
.collect::<Vec<_>>();
let revoked = rev_status_list
.state()
.iter()
.enumerate()
.filter_map(
|(idx, is_revoked)| {
if *is_revoked {
Some(idx as u32)
} else {
None
}
},
)
.collect::<Vec<_>>();
let registry = CryptoRevocationRegistry {
accum: rev_status_list.accum().ok_or_else(|| {
VcxAnoncredsError::InvalidState(
"Revocation registry delta cannot be created from revocation status list without \
accumulator"
.into(),
)
})?,
};
Ok(RevocationRegistryDelta {
value: RevocationRegistryDeltaValue {
prev_accum,
accum: registry.accum,
issued: Default::default(), // TODO
revoked,
},
})
}
#[derive(Debug, Copy, Clone)]
pub struct Anoncreds;
#[derive(Debug, Deserialize, Serialize, Clone)]
pub struct RevocationRegistryInfo {
pub id: RevocationRegistryDefinitionId,
pub curr_id: u32,
pub used_ids: HashSet<u32>,
}
impl Anoncreds {
async fn get_wallet_record_value<T>(
&self,
wallet: &impl BaseWallet,
category: RecordCategory,
id: &str,
) -> VcxAnoncredsResult<T>
where
T: DeserializeOwned,
{
let str_record = wallet.get_record(category, id).await?;
serde_json::from_str(str_record.value()).map_err(From::from)
}
async fn get_link_secret(
&self,
wallet: &impl BaseWallet,
link_secret_id: &LinkSecretId,
) -> VcxAnoncredsResult<LinkSecret> {
let ms_decimal = wallet
.get_record(RecordCategory::LinkSecret, link_secret_id)
.await?;
Ok(ms_decimal.value().try_into().unwrap())
}
async fn _get_credentials(
wallet: &impl BaseWallet,
wql: &str,
) -> VcxAnoncredsResult<Vec<(String, Credential)>> {
let records = wallet
.search_record(RecordCategory::Cred, Some(wql.into()))
.await?;
let id_cred_tuple_list: VcxAnoncredsResult<Vec<(String, Credential)>> = records
.into_iter()
.map(|record| {
let credential: Credential = serde_json::from_str(record.value())?;
Ok((record.name().into(), credential))
})
.collect();
id_cred_tuple_list
}
async fn _get_credentials_for_proof_req_for_attr_name(
&self,
wallet: &impl BaseWallet,
restrictions: Option<Value>,
attr_names: Vec<String>,
) -> VcxAnoncredsResult<Vec<(String, Credential)>> {
let mut attrs = Vec::new();
for name in attr_names {
let attr_marker_tag_name = _format_attribute_as_marker_tag_name(&name);
let wql_attr_query = json!({
attr_marker_tag_name: "1"
});
attrs.push(wql_attr_query);
}
let restrictions = restrictions.map(|x| x.to_owned());
let wql_query = if let Some(restrictions) = restrictions {
match restrictions {
Value::Array(restrictions) => {
let restrictions_wql = json!({ "$or": restrictions });
attrs.push(restrictions_wql);
json!({ "$and": attrs })
}
Value::Object(restriction) => {
attrs.push(Value::Object(restriction));
json!({ "$and": attrs })
}
Value::Null => {
json!({ "$and": attrs })
}
_ => Err(VcxAnoncredsError::InvalidInput(
"Invalid attribute restrictions (must be array or an object)".into(),
))?,
}
} else {
json!({ "$and": attrs })
};
let wql_query = serde_json::to_string(&wql_query)?;
Self::_get_credentials(wallet, &wql_query).await
}
}
#[async_trait]
impl BaseAnonCreds for Anoncreds {
async fn verifier_verify_proof(
&self,
proof_request_json: PresentationRequest,
proof_json: Presentation,
schemas_json: SchemasMap,
credential_defs_json: CredentialDefinitionsMap,
rev_reg_defs_json: Option<RevocationRegistryDefinitionsMap>,
rev_regs_json: Option<RevocationRegistriesMap>,
) -> VcxAnoncredsResult<bool> {
let presentation: AnoncredsPresentation = proof_json.convert(())?;
let pres_req: AnoncredsPresentationRequest = proof_request_json.convert(())?;
let schemas: HashMap<AnoncredsSchemaId, AnoncredsSchema> = schemas_json.convert(())?;
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_status_lists,
None, // no idea what this is
)?)
}
async fn issuer_create_and_store_revoc_reg(
&self,
wallet: &impl BaseWallet,
issuer_did: &Did,
cred_def_id: &CredentialDefinitionId,
tails_dir: &Path,
max_creds: u32,
tag: &str,
) -> VcxAnoncredsResult<(
RevocationRegistryDefinitionId,
RevocationRegistryDefinition,
RevocationRegistry,
)> {
let mut tails_writer = TailsFileWriter::new(Some(tails_dir.to_str().unwrap().to_string()));
let cred_def: AnoncredsCredentialDefinition = self
.get_wallet_record_value(wallet, RecordCategory::CredDef, &cred_def_id.to_string())
.await?;
let rev_reg_id =
make_revocation_registry_id(issuer_did, cred_def_id, tag, RegistryType::CL_ACCUM)?;
let (rev_reg_def, rev_reg_def_priv) = create_revocation_registry_def(
&cred_def,
AnoncredsCredentialDefinitionId::new(cred_def_id.to_string()).unwrap(),
tag,
RegistryType::CL_ACCUM,
max_creds,
&mut tails_writer,
)?;
let timestamp = OffsetDateTime::now_utc().unix_timestamp() as u64;
let rev_status_list = create_revocation_status_list(
&cred_def,
AnoncredsRevocationRegistryDefinitionId::new(rev_reg_id.to_string()).unwrap(),
&rev_reg_def,
&rev_reg_def_priv,
true,
Some(timestamp),
)?;
let opt_rev_reg: Option<CryptoRevocationRegistry> = (&rev_status_list).into();
let rev_reg = opt_rev_reg
.expect("creating a RevocationStatusList always generates a CryptoRevocationRegistry");
let rev_reg_info = RevocationRegistryInfo {
id: rev_reg_id.clone(),
curr_id: 0,
used_ids: HashSet::new(),
};
let str_rev_reg_info = serde_json::to_string(&rev_reg_info)?;
let record = Record::builder()
.name(rev_reg_id.0.clone())
.category(RecordCategory::RevRegInfo)
.value(str_rev_reg_info)
.build();
wallet.add_record(record).await?;
let mut rev_reg_def_val = serde_json::to_value(&rev_reg_def)?;
rev_reg_def_val
.as_object_mut()
.unwrap()
.insert("id".to_owned(), rev_reg_id.0.clone().into());
rev_reg_def_val
.as_object_mut()
.unwrap()
.insert("ver".to_owned(), "1.0".into());
rev_reg_def_val["value"]
.as_object_mut()
.unwrap()
.insert("issuanceType".to_string(), "ISSUANCE_BY_DEFAULT".into());
let str_rev_reg_def = serde_json::to_string(&rev_reg_def_val)?;
let record = Record::builder()
.name(rev_reg_id.0.clone())
.category(RecordCategory::RevRegDef)
.value(str_rev_reg_def.clone())
.build();
wallet.add_record(record).await?;
let str_rev_reg_def_priv = serde_json::to_string(&rev_reg_def_priv)?;
let record = Record::builder()
.name(rev_reg_id.0.clone())
.category(RecordCategory::RevRegDefPriv)
.value(str_rev_reg_def_priv)
.build();
wallet.add_record(record).await?;
let rev_reg = AnoncredsRevocationRegistry { value: rev_reg };
let str_rev_reg = serde_json::to_string(&rev_reg)?;
let record = Record::builder()
.name(rev_reg_id.0.clone())
.category(RecordCategory::RevReg)
.value(str_rev_reg.clone())
.build();
wallet.add_record(record).await?;
Ok((
rev_reg_id.to_string().try_into()?,
rev_reg_def.convert((rev_reg_id.to_string(),))?,
rev_reg.convert(())?,
))
}
async fn issuer_create_and_store_credential_def(
&self,
wallet: &impl BaseWallet,
issuer_did: &Did,
schema_id: &SchemaId,
schema_json: Schema,
config_json: CredentialDefinitionConfig,
) -> VcxAnoncredsResult<CredentialDefinition> {
let CredentialDefinitionConfig {
tag,
signature_type,
..
} = config_json.clone();
let cred_def_id = make_credential_definition_id(
issuer_did,
schema_id,
schema_json.seq_no,
&tag,
signature_type,
);
// If cred def already exists, return it
if let Ok(cred_def) = self
.get_wallet_record_value(wallet, RecordCategory::CredDef, &cred_def_id.0)
.await
{
// TODO! Convert?
return Ok(cred_def);
}
// Otherwise, create cred def
let (cred_def, cred_def_priv, cred_key_correctness_proof) =
anoncreds::issuer::create_credential_definition(
// Schema ID must be just the schema seq no for some reason
AnoncredsSchemaId::new_unchecked(schema_json.seq_no.unwrap().to_string()),
// SchemaId::new(schema_id).unwrap(),
&schema_json.clone().convert(())?,
schema_json.issuer_id.clone().convert(())?,
&tag,
signature_type.convert(())?,
config_json.convert(())?,
)?;
let mut cred_def_val = serde_json::to_value(&cred_def)?;
cred_def_val
.as_object_mut()
.map(|v| v.insert("id".to_owned(), cred_def_id.to_string().into()));
let str_cred_def = serde_json::to_string(&cred_def)?;
let record = Record::builder()
.name(cred_def_id.0.clone())
.category(RecordCategory::CredDef)
.value(str_cred_def.clone())
.build();
wallet.add_record(record).await?;
let str_cred_def_priv = serde_json::to_string(&cred_def_priv)?;
let record = Record::builder()
.name(cred_def_id.0.clone())
.category(RecordCategory::CredDefPriv)
.value(str_cred_def_priv)
.build();
wallet.add_record(record).await?;
let str_cred_key_proof = serde_json::to_string(&cred_key_correctness_proof)?;
let record = Record::builder()
.name(cred_def_id.0.clone())
.category(RecordCategory::CredKeyCorrectnessProof)
.value(str_cred_key_proof)
.build();
wallet.add_record(record).await?;
let record = Record::builder()
.name(schema_id.to_string())
.category(RecordCategory::CredSchema)
.value(serde_json::to_string(&schema_json)?)
.build();
let store_schema_res = wallet.add_record(record).await;
if let Err(e) = store_schema_res {
warn!(
"Storing schema {schema_json:?} failed - {e}. It's possible it is already stored."
)
}
let record = Record::builder()
.name(cred_def_id.0.clone())
.category(RecordCategory::CredMapSchemaId)
// .value(schema_id.to_string())
.value(json!({ "schemaId": schema_id }).to_string())
.build();
wallet.add_record(record).await?;
Ok(cred_def.convert((cred_def_id.to_string(),))?)
}
async fn issuer_create_credential_offer(
&self,
wallet: &impl BaseWallet,
cred_def_id: &CredentialDefinitionId,
) -> VcxAnoncredsResult<CredentialOffer> {
let correctness_proof = self
.get_wallet_record_value(
wallet,
RecordCategory::CredKeyCorrectnessProof,
&cred_def_id.to_string(),
)
.await?;
let schema_id_value = self
.get_wallet_record_value::<Value>(
wallet,
RecordCategory::CredMapSchemaId,
&cred_def_id.to_string(),
)
.await?;
let offer = anoncreds::issuer::create_credential_offer(
AnoncredsSchemaId::new(schema_id_value["schemaId"].as_str().unwrap()).unwrap(),
AnoncredsCredentialDefinitionId::new(cred_def_id.to_string()).unwrap(),
&correctness_proof,
)?;
Ok(offer.convert(())?)
}
async fn issuer_create_credential(
&self,
wallet: &impl BaseWallet,
cred_offer_json: CredentialOffer,
cred_req_json: CredentialRequest,
cred_values_json: CredentialValues,
rev_reg_id: Option<&RevocationRegistryDefinitionId>,
tails_dir: Option<&Path>,
) -> VcxAnoncredsResult<(Credential, Option<u32>)> {
let cred_offer: AnoncredsCredentialOffer = cred_offer_json.convert(())?;
let cred_request: AnoncredsCredentialRequest = cred_req_json.convert(())?;
let cred_values: AnoncredsCredentialValues = cred_values_json.convert(())?;
let cred_def_id = &cred_offer.cred_def_id.0;
let cred_def = self
.get_wallet_record_value(wallet, RecordCategory::CredDef, cred_def_id)
.await?;
let cred_def_private = self
.get_wallet_record_value(wallet, RecordCategory::CredDefPriv, cred_def_id)
.await?;
let rev_reg_id = rev_reg_id.map(ToString::to_string);
let mut revocation_config_parts = match (tails_dir, &rev_reg_id) {
(Some(tails_dir), Some(rev_reg_def_id)) => {
let rev_reg_def: AnoncredsRevocationRegistryDefinition = self
.get_wallet_record_value(wallet, RecordCategory::RevRegDef, rev_reg_def_id)
.await?;
let rev_reg_def_priv = self
.get_wallet_record_value(wallet, RecordCategory::RevRegDefPriv, rev_reg_def_id)
.await?;
let rev_reg: AnoncredsRevocationRegistry = self
.get_wallet_record_value(wallet, RecordCategory::RevReg, rev_reg_def_id)
.await?;
let rev_reg_info: RevocationRegistryInfo = self
.get_wallet_record_value(wallet, RecordCategory::RevRegInfo, rev_reg_def_id)
.await?;
let rev_reg_def_id =
AnoncredsRevocationRegistryDefinitionId::new(rev_reg_def_id).unwrap();
Some((
rev_reg_def,
rev_reg_def_id,
rev_reg_def_priv,
rev_reg,
rev_reg_info,
tails_dir,
))
}
(None, None) => None,
(tails_dir, rev_reg_def_id) => {
warn!(
"Missing revocation config params: tails_dir: {tails_dir:?} - \
{rev_reg_def_id:?}; Issuing non revokable credential"
);
None
}
};
let rev_status_list = match &revocation_config_parts {
Some((rev_reg_def, rev_reg_def_id, rev_reg_def_priv, _, _, _)) => {
Some(create_revocation_status_list(
&cred_def,
rev_reg_def_id.clone(),
rev_reg_def,
rev_reg_def_priv,
true,
None,
)?)
}
_ => None,
};
let revocation_config = match (&mut revocation_config_parts, &rev_status_list) {
(
Some((rev_reg_def, _, rev_reg_def_priv, _, rev_reg_info, _)),
Some(rev_status_list),
) => {
rev_reg_info.curr_id += 1;
if rev_reg_info.curr_id > rev_reg_def.value.max_cred_num {
return Err(VcxAnoncredsError::ActionNotSupported(
"The revocation registry is full".into(),
));
}
rev_reg_info.used_ids.insert(rev_reg_info.curr_id);
let revocation_config = CredentialRevocationConfig {
reg_def: rev_reg_def,
reg_def_private: rev_reg_def_priv,
registry_idx: rev_reg_info.curr_id,
status_list: rev_status_list,
};
Some(revocation_config)
}
_ => None,
};
let cred = anoncreds::issuer::create_credential(
&cred_def,
&cred_def_private,
&cred_offer,
&cred_request,
cred_values,
revocation_config,
)?;
let rev_reg = cred.rev_reg.as_ref();
let cred_rev_id =
if let (Some(rev_reg_id), Some(rev_reg), Some((_, _, _, _, rev_reg_info, _))) =
(rev_reg_id, rev_reg, revocation_config_parts)
{
let cred_rev_id = rev_reg_info.curr_id;
let str_rev_reg_info = serde_json::to_string(&rev_reg_info)?;
let rev_reg = AnoncredsRevocationRegistry {
value: rev_reg.clone(),
};
let str_rev_reg = serde_json::to_string(&rev_reg)?;
wallet
.update_record_value(RecordCategory::RevReg, &rev_reg_id, &str_rev_reg)
.await?;
wallet
.update_record_value(RecordCategory::RevRegInfo, &rev_reg_id, &str_rev_reg_info)
.await?;
Some(cred_rev_id)
} else {
None
};
Ok((cred.convert(())?, cred_rev_id))
}
#[allow(clippy::too_many_arguments)]
async fn prover_create_proof(
&self,
wallet: &impl BaseWallet,
proof_req_json: PresentationRequest,
requested_credentials_json: RequestedCredentials,
link_secret_id: &LinkSecretId,
schemas_json: SchemasMap,
credential_defs_json: CredentialDefinitionsMap,
revoc_states_json: Option<RevocationStatesMap>,
) -> VcxAnoncredsResult<Presentation> {
let pres_req: AnoncredsPresentationRequest = proof_req_json.convert(())?;
let requested_attributes = requested_credentials_json.requested_attributes;
let requested_predicates = requested_credentials_json.requested_predicates;
let self_attested_attributes = requested_credentials_json.self_attested_attributes;
let schemas: HashMap<AnoncredsSchemaId, AnoncredsSchema> = schemas_json.convert(())?;
let cred_defs: HashMap<AnoncredsCredentialDefinitionId, AnoncredsCredentialDefinition> =
credential_defs_json.convert(())?;
let mut present_credentials: PresentCredentials<AnoncredsCredential> =
PresentCredentials::default();
let mut proof_details_by_cred_id: HashMap<
String,
(
AnoncredsCredential,
Option<u64>,
Option<AnoncredsCredentialRevocationState>,
Vec<(String, bool)>,
Vec<String>,
),
> = HashMap::new();
// add cred data and referent details for each requested attribute
for (reft, detail) in requested_attributes {
let cred_id = &detail.cred_id;
let revealed = detail.revealed;
if let Some((_, _, _, req_attr_refts_revealed, _)) =
proof_details_by_cred_id.get_mut(cred_id)
{
// mapping made for this credential already, add reft and its revealed status
req_attr_refts_revealed.push((reft.to_string(), revealed));
} else {
let credential = self
.get_wallet_record_value(wallet, RecordCategory::Cred, cred_id)
.await?;
let (timestamp, rev_state) = get_rev_state(
cred_id,
&credential,
detail.timestamp,
revoc_states_json.as_ref(),
)?;
proof_details_by_cred_id.insert(
cred_id.to_string(),
(
credential.convert(())?,
timestamp,
rev_state.map(|v| v.convert(())).transpose()?,
vec![(reft.to_string(), revealed)],
vec![],
),
);
}
}
// add cred data and referent details for each requested predicate
for (reft, detail) in requested_predicates {
let cred_id = &detail.cred_id;
if let Some((_, _, _, _, req_preds_refts)) = proof_details_by_cred_id.get_mut(cred_id) {
// mapping made for this credential already, add reft
req_preds_refts.push(reft.to_string());
} else {
let credential = self
.get_wallet_record_value(wallet, RecordCategory::Cred, cred_id)
.await?;
let (timestamp, rev_state) = get_rev_state(
cred_id,
&credential,
detail.timestamp,
revoc_states_json.as_ref(),
)?;
proof_details_by_cred_id.insert(
cred_id.to_string(),
(
credential.convert(())?,
timestamp,
rev_state.map(|v| v.convert(())).transpose()?,
vec![],
vec![reft.to_string()],
),
);
}
}
// add all accumulated requested attributes and requested predicates to credx
// [PresentCredential] object
for (
_cred_id,
(credential, timestamp, rev_state, req_attr_refts_revealed, req_preds_refts),
) in proof_details_by_cred_id.iter()
{
let mut add_cred =
present_credentials.add_credential(credential, *timestamp, rev_state.as_ref());
for (referent, revealed) in req_attr_refts_revealed {
add_cred.add_requested_attribute(referent, *revealed);
}
for referent in req_preds_refts {
add_cred.add_requested_predicate(referent);
}
}
let link_secret = self.get_link_secret(wallet, link_secret_id).await?;
let presentation = anoncreds::prover::create_presentation(
&pres_req,
present_credentials,
Some(self_attested_attributes),
&link_secret,
&schemas,
&cred_defs,
)?;
Ok(presentation.convert(())?)
}
async fn prover_get_credential(
&self,
wallet: &impl BaseWallet,
cred_id: &CredentialId,
) -> VcxAnoncredsResult<RetrievedCredentialInfo> {
let cred = self
.get_wallet_record_value(wallet, RecordCategory::Cred, cred_id)
.await?;
_make_cred_info(cred_id, &cred)
}
async fn prover_get_credentials(
&self,
wallet: &impl BaseWallet,
filter_json: Option<&str>,
) -> VcxAnoncredsResult<Vec<RetrievedCredentialInfo>> {
// filter_json should map to WQL query directly
// TODO - future - may wish to validate the filter_json for more accurate error reporting
let creds_wql = filter_json.map_or("{}", |x| x);
let creds = Self::_get_credentials(wallet, creds_wql).await?;
creds
.iter()
.map(|(credential_id, cred)| _make_cred_info(credential_id, cred))
.collect()
}
async fn prover_get_credentials_for_proof_req(
&self,
wallet: &impl BaseWallet,
proof_request_json: PresentationRequest,
) -> VcxAnoncredsResult<RetrievedCredentials> {
let requested_attributes = &proof_request_json.value().requested_attributes;
let requested_predicates = &proof_request_json.value().requested_predicates;
let mut referents: HashSet<String> = HashSet::new();
requested_attributes.iter().for_each(|(k, _)| {
referents.insert(k.to_string());
});
requested_predicates.iter().for_each(|(k, _)| {
referents.insert(k.to_string());
});
let mut cred_by_attr = RetrievedCredentials::default();
for reft in referents {
let (names, non_revoked, restrictions) = match requested_attributes.get(&reft) {
Some(attribute_info) => {
let attr_names = match (
attribute_info.name.to_owned(),
attribute_info.names.to_owned(),
) {
(Some(name), None) => vec![_normalize_attr_name(&name)],
(None, Some(names)) => names
.iter()
.map(String::as_str)
.map(_normalize_attr_name)
.collect::<Vec<_>>(),
_ => Err(VcxAnoncredsError::InvalidInput(
"exactly one of 'name' or 'names' must be present".into(),
))?,
};
(
attr_names,
attribute_info.non_revoked.to_owned(),
attribute_info.restrictions.to_owned(),
)
}
None => match requested_predicates.get(&reft) {
Some(requested_val) => (
vec![requested_val.name.to_owned()],
requested_val.non_revoked.to_owned(),
requested_val.restrictions.to_owned(),
),
None => Err(VcxAnoncredsError::InvalidProofRequest(
"Requested attribute or predicate not found in proof request".into(),
))?,
},
};
let credx_creds = self
._get_credentials_for_proof_req_for_attr_name(
wallet,
restrictions.map(serde_json::to_value).transpose()?,
names,
)
.await?;
let mut credentials_json = vec![];
for (cred_id, credx_cred) in credx_creds {
credentials_json.push(RetrievedCredentialForReferent {
cred_info: _make_cred_info(&cred_id, &credx_cred)?,
interval: non_revoked.clone(),
});
}
cred_by_attr
.credentials_by_referent
.insert(reft, credentials_json);
}
Ok(cred_by_attr)
}
| rust | Apache-2.0 | 2d3034ed73ba8d49e0f72251b4c7cfb859a1efe7 | 2026-01-04T20:24:59.602734Z | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.