siera-agent 0.2.0

Structures and traits related to an Aries agent.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103

use crate::error::{Error, Result};
use async_trait::async_trait;
use serde::Deserialize;
use serde::Serialize;
use serde_json::Value;
use std::str::FromStr;

/// Response from the cloudagent when a proof request is created
#[derive(Default, Debug, Clone, Eq, PartialEq, Serialize, Deserialize)]
pub struct ProofRequestResponse {
    /// The state of the proof request
    pub state: String,

    /// The presentation request as an object
    pub presentation_request: Value,

    /// The last time the proof request was updated
    pub updated_at: String,

    /// The connection id to which the proof request is send to
    pub connection_id: String,

    /// The thread id that can be used to reference this proof request
    pub thread_id: String,

    /// A dictionary of the presentation request
    pub presentation_request_dict: Value,

    /// Your role in the proof request flow
    pub role: String,

    /// Whether it should automatically respond in the proof request flow
    pub auto_present: bool,

    /// The presentation exhange id that can be used in the other presentation exchange steps
    pub presentation_exchange_id: String,

    /// When the proof request was created
    pub created_at: String,

    /// Who the initiator was of the proof request
    pub initiator: String,
}

/// A simple predicate enum
/// The first string is the name of the key/value pair
/// The second string is the operator that is used `>=`, `<=`, `=`, `>` or `>`
/// The third string is the the value that should be evaluated with
#[derive(Debug, Clone)]
pub struct Predicate(pub String, pub String, pub String);

impl FromStr for Predicate {
    type Err = Error;
    fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
        let mut res = s.split(',');
        let name = res
            .next()
            .ok_or_else(|| Error::UnableToParseOutValue(s.to_owned()))?;
        let operator = res
            .next()
            .ok_or_else(|| Error::UnableToParseOutValue(s.to_owned()))?;
        let value = res
            .next()
            .ok_or_else(|| Error::UnableToParseOutValue(s.to_owned()))?;

        validate_operator(operator).map_err(|_| Error::InvalidOperator(operator.to_owned()))?;
        Ok(Self(name.to_owned(), operator.to_owned(), value.to_owned()))
    }
}

/// Simple validation to check if the supplied operator is valid
fn validate_operator(op: &str) -> Result<()> {
    if vec![">=", "<=", "=", ">", "<"]
        .iter()
        .map(|o| String::from(*o))
        .any(|o| o == *op)
    {
        return Ok(());
    };
    Err(Error::InvalidOperator(op.to_owned()).into())
}

/// Options supplied when a proof request is created
pub struct ProofRequestOptions {
    /// The connection id to which the proof request is send to
    pub connection_id: String,

    /// The name of the proof request
    pub name: String,

    /// All the attributes that are requested from the other agent
    pub attributes: Vec<String>,

    /// All the predicates that are requested from the other agent
    pub predicates: Vec<(String, String, i32)>,
}

/// Generic cloudagent proof module
#[async_trait]
pub trait ProofModule {
    /// Send a proof request via the connection id to another agent
    async fn send_request(&self, options: ProofRequestOptions) -> Result<ProofRequestResponse>;
}