flmodules/testing/
wallet.rs

1use flarch::{broker::Broker, broker::BrokerError};
2use flcrypto::{
3    access::Condition,
4    signer::{Signer, SignerTrait, Verifier, VerifierTrait},
5    signer_ed25519::SignerEd25519,
6};
7use serde::{Deserialize, Serialize};
8use thiserror::Error;
9
10use crate::dht_storage::{
11    broker::{DHTStorageIn, DHTStorageOut},
12    core::{Cuckoo, RealmConfig},
13};
14
15use crate::flo::{
16    crypto::{BadgeCond, FloBadge, FloVerifier},
17    flo::{FloError, FloWrapper},
18    realm::{FloRealm, RealmID},
19};
20
21#[derive(Debug, Serialize, Deserialize, Clone)]
22pub struct Testing {
23    data: String,
24}
25
26pub type FloTesting = FloWrapper<Testing>;
27
28#[derive(Error, Debug)]
29pub enum WalletError {
30    #[error("BrokerError({0})")]
31    BrokerError(#[from] BrokerError),
32    #[error("FloError({0})")]
33    FloError(#[from] FloError),
34}
35
36#[derive(Default)]
37pub struct Wallet {
38    realm_id: RealmID,
39    pub signer: Option<Signer>,
40    pub verifier: Option<Verifier>,
41    pub verifier_flo: Option<FloVerifier>,
42    pub badge_condition: Option<Condition>,
43    pub badge: Option<BadgeCond>,
44    pub badge_flo: Option<FloBadge>,
45    pub realm: Option<FloRealm>,
46}
47
48impl Wallet {
49    pub fn new() -> Self {
50        Self::default()
51    }
52
53    pub fn get_signer(&mut self) -> Signer {
54        self.signer.get_or_insert(SignerEd25519::new()).clone()
55    }
56
57    pub fn get_verifier(&mut self) -> Verifier {
58        let signer = self.get_signer();
59        self.verifier.get_or_insert(signer.verifier()).clone()
60    }
61
62    pub fn get_verifier_flo(&mut self) -> FloVerifier {
63        let verifier = self.get_verifier();
64        let force_id = *verifier.get_id();
65        self.verifier_flo
66            .get_or_insert(
67                FloVerifier::from_force_id(self.realm_id.clone(), verifier, force_id).unwrap(),
68            )
69            .clone()
70    }
71
72    pub fn get_badge_cond(&mut self) -> Condition {
73        let verifier = self.get_verifier();
74        self.badge_condition
75            .get_or_insert(Condition::Verifier(verifier))
76            .clone()
77    }
78
79    pub fn get_badge(&mut self) -> BadgeCond {
80        let condition = self.get_badge_cond();
81        self.badge
82            .get_or_insert(BadgeCond::new(condition.to_link()))
83            .clone()
84    }
85
86    pub fn get_badge_flo(&mut self) -> FloBadge {
87        let badge = self.get_badge();
88        let badge_rules = self.get_badge_cond();
89        let signer = self.get_signer();
90        self.badge_flo
91            .get_or_insert(
92                FloBadge::from_type(self.realm_id.clone(), badge_rules, badge, &[&signer]).unwrap(),
93            )
94            .clone()
95    }
96
97    pub fn create_realm(&mut self, name: &str, max_space: u64, max_flo_size: u32) -> FloRealm {
98        let cond = self.get_badge_cond();
99        let signer = self.get_signer();
100        FloRealm::new(
101            name,
102            cond,
103            RealmConfig {
104                max_space,
105                max_flo_size,
106            },
107            &[&signer],
108        )
109        .unwrap()
110    }
111
112    pub fn get_realm(&mut self) -> FloRealm {
113        let new_realm = self.create_realm("root", 1_000_000, 10_000);
114        self.realm.get_or_insert(new_realm).clone()
115    }
116
117    pub fn set_realm_id(&mut self, realm_id: RealmID) {
118        self.verifier_flo = None;
119        self.badge_flo = None;
120        self.realm_id = realm_id;
121        self.get_verifier_flo();
122        self.get_badge_flo();
123    }
124
125    pub fn store(
126        &mut self,
127        dht_storage: &mut Broker<DHTStorageIn, DHTStorageOut>,
128    ) -> anyhow::Result<()> {
129        for flo in [self.get_verifier_flo().flo(), self.get_badge_flo().flo()] {
130            dht_storage.emit_msg_in(DHTStorageIn::StoreFlo(flo.clone()))?;
131        }
132
133        Ok(())
134    }
135}
136
137impl Clone for Wallet {
138    fn clone(&self) -> Self {
139        Self {
140            realm_id: self.realm_id.clone(),
141            signer: self.signer.clone(),
142            verifier: self.verifier.clone(),
143            verifier_flo: self.verifier_flo.clone(),
144            badge_condition: self.badge_condition.clone(),
145            badge: self.badge.clone(),
146            badge_flo: self.badge_flo.clone(),
147            realm: self.realm.clone(),
148        }
149    }
150}
151
152impl FloTesting {
153    pub fn new(rid: RealmID, data: &str, signer: &Signer) -> Self {
154        FloWrapper::from_type(
155            rid,
156            Condition::Pass,
157            Testing {
158                data: data.to_string(),
159            },
160            &[signer],
161        )
162        .unwrap()
163    }
164
165    pub fn new_cuckoo(rid: RealmID, data: &str, cuckoo: Cuckoo, signer: &Signer) -> Self {
166        FloWrapper::from_type_cuckoo(
167            rid,
168            Condition::Pass,
169            cuckoo,
170            Testing {
171                data: data.to_string(),
172            },
173            &[signer],
174        )
175        .unwrap()
176    }
177}
flmodules/testing/wallet.rs

flmodules/testing/
wallet.rs
