1use crate::cesr::signing::{Salter, Signer};
2use crate::cesr::{mtr_dex, Tiers};
3use crate::errors::MatterError;
4use crate::Matter;
5use std::fmt;
6use std::fmt::Debug;
7
8#[allow(dead_code)]
10#[derive(Debug, Clone, Copy, PartialEq)]
11pub enum Algos {
12 Randy,
13 Salty,
14}
15
16impl fmt::Display for Algos {
17 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
18 match self {
19 Algos::Randy => write!(f, "randy"),
20 Algos::Salty => write!(f, "salty"),
21 }
22 }
23}
24
25impl Algos {
26 pub fn from_str(s: &str) -> Result<Self, MatterError> {
27 match s.to_lowercase().as_str() {
28 "randy" => Ok(Algos::Randy),
29 "salty" => Ok(Algos::Salty),
30 _ => Err(MatterError::ValueError(format!(
31 "Unsupported creation algorithm = {}.",
32 s
33 ))),
34 }
35 }
36}
37
38pub trait Creator: Debug {
40 fn create(
42 &self,
43 codes: Option<Vec<&str>>,
44 count: Option<usize>,
45 code: Option<&str>,
46 pidx: Option<usize>,
47 ridx: Option<usize>,
48 kidx: Option<usize>,
49 transferable: Option<bool>,
50 temp: Option<bool>,
51 ) -> Vec<Signer>;
52
53 fn salt(&self) -> String;
55
56 fn stem(&self) -> String;
58
59 fn tier(&self) -> Option<&Tiers>;
61}
62
63#[derive(Debug)]
65pub struct RandyCreator {
66 }
68
69impl RandyCreator {
70 pub fn new() -> Self {
72 RandyCreator {}
73 }
74}
75
76impl Creator for RandyCreator {
77 fn create(
78 &self,
79 codes: Option<Vec<&str>>,
80 count: Option<usize>,
81 code: Option<&str>,
82 _pidx: Option<usize>,
83 _ridx: Option<usize>,
84 _kidx: Option<usize>,
85 transferable: Option<bool>,
86 _temp: Option<bool>,
87 ) -> Vec<Signer> {
88 let count = count.unwrap_or(1);
89 let code = code.unwrap_or(mtr_dex::ED25519_SEED);
90 let transferable = transferable.unwrap_or(true);
91
92 let mut signers = Vec::new();
93
94 if let Some(code_list) = codes {
96 for &c in code_list.iter() {
97 signers.push(
98 Signer::new(None, Some(c), Some(transferable))
99 .expect("Failed to create signer"),
100 );
101 }
102 } else {
103 for _ in 0..count {
104 signers.push(
105 Signer::new(None, Some(code), Some(transferable))
106 .expect("Failed to create signer"),
107 );
108 }
109 }
110
111 signers
112 }
113
114 fn salt(&self) -> String {
115 String::new()
116 }
117
118 fn stem(&self) -> String {
119 String::new()
120 }
121
122 fn tier(&self) -> Option<&Tiers> {
123 None
124 }
125}
126
127#[derive(Debug)]
129pub struct SaltyCreator {
130 salter: Salter,
131 stem: String,
132}
133
134impl SaltyCreator {
135 pub fn new(
137 salt: Option<&str>,
138 stem: Option<&str>,
139 tier: Option<Tiers>,
140 ) -> Result<Self, MatterError> {
141 let salter = if let Some(s) = salt {
142 Salter::from_qb64_and_tier(s, tier)
143 } else {
144 Salter::new(None, None, tier)
145 }?;
146
147 let stem = stem.unwrap_or("").to_string();
148
149 Ok(SaltyCreator { salter, stem })
150 }
151}
152
153impl Creator for SaltyCreator {
154 fn create(
155 &self,
156 codes: Option<Vec<&str>>,
157 count: Option<usize>,
158 code: Option<&str>,
159 pidx: Option<usize>,
160 ridx: Option<usize>,
161 kidx: Option<usize>,
162 transferable: Option<bool>,
163 temp: Option<bool>,
164 ) -> Vec<Signer> {
165 let count = count.unwrap_or(1);
166 let code = code.unwrap_or(mtr_dex::ED25519_SEED);
167 let transferable = transferable.unwrap_or(true);
168
169 let pidx = pidx.unwrap_or(0);
171 let ridx = ridx.unwrap_or(0);
172 let kidx = kidx.unwrap_or(0);
173 let temp = temp.unwrap_or(false);
174
175 self.create_with_options(codes, count, code, pidx, ridx, kidx, transferable, temp)
176 }
177
178 fn salt(&self) -> String {
179 self.salter.qb64()
180 }
181
182 fn stem(&self) -> String {
183 self.stem.clone()
184 }
185
186 fn tier(&self) -> Option<&Tiers> {
187 Some(self.salter.tier())
188 }
189}
190
191impl SaltyCreator {
192 pub fn create_with_options(
194 &self,
195 codes: Option<Vec<&str>>,
196 count: usize,
197 code: &str,
198 pidx: usize,
199 ridx: usize,
200 kidx: usize,
201 transferable: bool,
202 temp: bool,
203 ) -> Vec<Signer> {
204 let mut signers = Vec::new();
205
206 let code_list = if let Some(codes) = codes {
208 codes
209 } else {
210 vec![code; count]
211 };
212
213 let stem = if !self.stem.is_empty() {
215 self.stem.clone()
216 } else {
217 format!("{:x}", pidx)
218 };
219
220 for (i, &code) in code_list.iter().enumerate() {
222 let path = format!("{}{:x}{:x}", stem, ridx, kidx + i);
223
224 let tier_option = if *self.salter.tier() == Tiers::HIGH {
226 Some(&Tiers::HIGH)
227 } else if *self.salter.tier() == Tiers::MED {
228 Some(&Tiers::MED)
229 } else if *self.salter.tier() == Tiers::LOW {
230 Some(&Tiers::LOW)
231 } else {
232 None
233 };
234
235 match self
236 .salter
237 .signer(Some(code), Some(transferable), &path, tier_option, temp)
238 {
239 Ok(signer) => signers.push(signer),
240 Err(e) => {
241 eprintln!("Error creating signer: {:?}", e);
242 }
244 }
245 }
246
247 signers
248 }
249}
250
251impl Default for RandyCreator {
253 fn default() -> Self {
254 Self::new()
255 }
256}
257
258#[derive(Debug)]
260pub struct Creatory {
261 algo: Algos,
262}
263
264impl Creatory {
265 pub fn new(algo: Algos) -> Self {
267 Creatory { algo }
268 }
269
270 pub fn make(
272 &self,
273 salt: Option<&str>,
274 stem: Option<&str>,
275 tier: Option<Tiers>,
276 ) -> Result<Box<dyn Creator>, MatterError> {
277 match self.algo {
278 Algos::Randy => Ok(Box::new(RandyCreator::new())),
279 Algos::Salty => {
280 let salty = SaltyCreator::new(salt, stem, tier)?;
281 Ok(Box::new(salty))
282 }
283 }
284 }
285}
286
287pub struct CreatoryBuilder {
289 algo: Algos,
290 salt: Option<String>,
291 stem: Option<String>,
292 tier: Option<Tiers>,
293}
294
295impl CreatoryBuilder {
296 pub fn new(algo: Algos) -> Self {
297 CreatoryBuilder {
298 algo,
299 salt: None,
300 stem: None,
301 tier: None,
302 }
303 }
304
305 pub fn with_salt(mut self, salt: &str) -> Self {
306 self.salt = Some(salt.to_string());
307 self
308 }
309
310 pub fn with_stem(mut self, stem: &str) -> Self {
311 self.stem = Some(stem.to_string());
312 self
313 }
314
315 pub fn with_tier(mut self, tier: Tiers) -> Self {
316 self.tier = Some(tier);
317 self
318 }
319
320 pub fn build(self) -> Result<Box<dyn Creator>, MatterError> {
321 match self.algo {
322 Algos::Randy => Ok(Box::new(RandyCreator::new())),
323 Algos::Salty => {
324 let salt_ref = self.salt.as_deref();
325 let stem_ref = self.stem.as_deref();
326 let tier = self.tier;
327
328 let salty = SaltyCreator::new(salt_ref, stem_ref, tier)?;
329 Ok(Box::new(salty))
330 }
331 }
332 }
333}
334
335impl Default for Creatory {
337 fn default() -> Self {
338 Self::new(Algos::Salty)
339 }
340}
341
342#[cfg(test)]
343mod tests {
344 use super::*;
345 use crate::cesr::non_trans_dex;
346 use crate::Matter;
347
348 #[test]
349 fn test_randy_creator() -> Result<(), MatterError> {
350 let creator = RandyCreator::new();
352
353 assert_eq!(creator.salt(), "");
355 assert_eq!(creator.stem(), "");
356 assert_eq!(creator.tier(), None);
357
358 let signers = creator.create(None, None, None, None, None, None, None, None);
360 assert_eq!(signers.len(), 1);
361
362 let signer = &signers[0];
363 assert_eq!(signer.code(), mtr_dex::ED25519_SEED);
364 assert_eq!(signer.verfer().code(), mtr_dex::ED25519);
365 assert!(!non_trans_dex::TUPLE.contains(&signer.verfer().code()));
366
367 let signers = creator.create(
369 None,
370 Some(2),
371 None,
372 None,
373 None,
374 None,
375 Some(false),
376 Some(false),
377 );
378 assert_eq!(signers.len(), 2);
379
380 for signer in &signers {
381 assert_eq!(signer.code(), mtr_dex::ED25519_SEED);
382 assert_eq!(signer.verfer().code(), mtr_dex::ED25519N);
383 assert!(non_trans_dex::TUPLE.contains(&signer.verfer().code()));
384 }
385
386 let codes = vec![mtr_dex::ED25519_SEED, mtr_dex::ED25519_SEED];
388 let signers = creator.create(Some(codes), None, None, None, None, None, None, None);
389 assert_eq!(signers.len(), 2);
390
391 for signer in &signers {
392 assert_eq!(signer.code(), mtr_dex::ED25519_SEED);
393 assert_eq!(signer.verfer().code(), mtr_dex::ED25519);
394 }
395
396 Ok(())
397 }
398
399 #[test]
400 fn test_salty_creator() -> Result<(), MatterError> {
401 let creator = SaltyCreator::new(None, None, None)?;
403
404 assert!(!creator.salt().is_empty()); assert_eq!(creator.stem(), "");
407 assert_eq!(creator.tier(), Some(&Tiers::LOW)); assert_eq!(creator.salter.code(), mtr_dex::SALT_128);
411
412 let signers = creator.create(None, None, None, None, None, None, None, None);
414 assert_eq!(signers.len(), 1);
415
416 let signer = &signers[0];
417 assert_eq!(signer.code(), mtr_dex::ED25519_SEED);
418 assert_eq!(signer.verfer().code(), mtr_dex::ED25519);
419 assert!(!non_trans_dex::TUPLE.contains(&signer.verfer().code()));
420
421 let signers = creator.create(
423 None,
424 Some(2),
425 None,
426 None,
427 None,
428 None,
429 Some(false),
430 Some(false),
431 );
432 assert_eq!(signers.len(), 2);
433 assert_eq!(signers.len(), 2);
434
435 for signer in &signers {
436 assert_eq!(signer.code(), mtr_dex::ED25519_SEED);
437 assert_eq!(signer.verfer().code(), mtr_dex::ED25519N);
438 assert!(non_trans_dex::TUPLE.contains(&signer.verfer().code()));
439 }
440
441 let raw = b"0123456789abcdef";
443 let salt = Salter::new(Some(raw), None, None)?.qb64();
444 assert_eq!(salt, "0AAwMTIzNDU2Nzg5YWJjZGVm");
445
446 let creator = SaltyCreator::new(Some(&salt), None, None)?;
447 assert_eq!(creator.salt(), salt);
448 assert_eq!(creator.salter.raw(), raw);
449
450 let signers = creator.create(None, None, None, None, None, None, None, None);
452 assert_eq!(signers.len(), 1);
453
454 let signer = &signers[0];
455 assert_eq!(signer.code(), mtr_dex::ED25519_SEED);
456 assert_eq!(
457 signer.qb64(),
458 "APMJe0lwOpwnX9PkvX1mh26vlzGYl6RWgWGclc8CAQJ9"
459 );
460 assert_eq!(signer.verfer().code(), mtr_dex::ED25519);
461 assert!(!non_trans_dex::TUPLE.contains(&signer.verfer().code()));
462 assert_eq!(
463 signer.verfer().qb64(),
464 "DMZy6qbgnKzvCE594tQ4SPs6pIECXTYQBH7BkC4hNY3E"
465 );
466
467 let signers =
469 creator.create_with_options(None, 1, mtr_dex::ED25519_SEED, 0, 0, 0, false, true);
470 assert_eq!(signers.len(), 1);
471
472 let signer = &signers[0];
473 assert_eq!(signer.code(), mtr_dex::ED25519_SEED);
474 assert_eq!(
475 signer.qb64(),
476 "AMGrAM0noxLpRteO9mxGT-yzYSrKFwJMuNI4KlmSk26e"
477 );
478 assert_eq!(signer.verfer().code(), mtr_dex::ED25519N);
479 assert!(non_trans_dex::TUPLE.contains(&signer.verfer().code()));
480 assert_eq!(
481 signer.verfer().qb64(),
482 "BFRtyHAjSuJaRX6TDPva35GN11VHAruaOXMc79ZYDKsT"
483 );
484
485 Ok(())
486 }
487
488 #[test]
489 fn test_creatory_factory() -> Result<(), MatterError> {
490 let creatory = Creatory::new(Algos::Randy);
492 let creator = creatory.make(None, None, None)?;
493
494 assert!(creator.salt().is_empty());
496 assert!(creator.stem().is_empty());
497 assert!(creator.tier().is_none());
498
499 let signers = creator.create(None, None, None, None, None, None, None, None);
500 assert_eq!(signers.len(), 1);
501 assert_eq!(signers[0].code(), mtr_dex::ED25519_SEED);
502
503 let raw = b"0123456789abcdef";
505 let salt = Salter::new(Some(raw), None, None)?.qb64();
506
507 let creatory = Creatory::new(Algos::Salty);
508 let creator = creatory.make(Some(&salt), None, None)?;
509
510 assert_eq!(creator.salt(), salt);
512 assert_eq!(creator.stem(), "");
513 assert_eq!(creator.tier(), Some(&Tiers::LOW));
514
515 let creator = CreatoryBuilder::new(Algos::Salty)
517 .with_salt(&salt)
518 .with_stem("test-stem")
519 .with_tier(Tiers::HIGH)
520 .build()?;
521
522 assert_eq!(creator.salt(), salt);
523 assert_eq!(creator.stem(), "test-stem");
524 assert_eq!(creator.tier(), Some(&Tiers::HIGH));
525
526 Ok(())
527 }
528
529 #[test]
530 fn test_algos_enum() {
531 assert_eq!(Algos::Randy.to_string(), "randy");
533 assert_eq!(Algos::Salty.to_string(), "salty");
534
535 assert_eq!(Algos::from_str("randy").unwrap(), Algos::Randy);
536 assert_eq!(Algos::from_str("RANDY").unwrap(), Algos::Randy);
537 assert_eq!(Algos::from_str("salty").unwrap(), Algos::Salty);
538 assert_eq!(Algos::from_str("SALTY").unwrap(), Algos::Salty);
539
540 let result = Algos::from_str("invalid");
542 assert!(result.is_err());
543 }
544
545 #[test]
546 fn test_error_handling() -> Result<(), MatterError> {
547 let result = SaltyCreator::new(Some("invalid_salt"), None, None);
549 assert!(result.is_err());
550
551 Ok(())
552 }
553
554 #[test]
555 fn test_deterministic_creation() -> Result<(), MatterError> {
556 let raw = b"0123456789abcdef";
558 let salt = Salter::new(Some(raw), None, None)?.qb64();
559
560 let creator1 = SaltyCreator::new(Some(&salt), Some("test"), None)?;
561 let creator2 = SaltyCreator::new(Some(&salt), Some("test"), None)?;
562
563 let signers1 = creator1.create(None, None, None, None, None, None, None, None);
564 let signers2 = creator2.create(None, None, None, None, None, None, None, None);
565
566 assert_eq!(signers1[0].qb64(), signers2[0].qb64());
567 assert_eq!(signers1[0].verfer().qb64(), signers2[0].verfer().qb64());
568
569 let creator3 = SaltyCreator::new(Some(&salt), Some("different"), None)?;
571 let signers3 = creator3.create(None, None, None, None, None, None, None, None);
572
573 assert_ne!(signers1[0].qb64(), signers3[0].qb64());
574 assert_ne!(signers1[0].verfer().qb64(), signers3[0].verfer().qb64());
575
576 Ok(())
577 }
578
579 #[test]
580 fn test_create_with_codes() -> Result<(), MatterError> {
581 let creator = RandyCreator::new();
583
584 let codes = vec![mtr_dex::ED25519_SEED, mtr_dex::ED25519_SEED];
585 let signers = creator.create(Some(codes), None, None, None, None, None, None, None);
586
587 assert_eq!(signers.len(), 2);
588 assert_eq!(signers[0].code(), mtr_dex::ED25519_SEED);
589 assert_eq!(signers[1].code(), mtr_dex::ED25519_SEED);
590
591 Ok(())
592 }
593
594 #[test]
595 fn test_salty_creator_path_generation() -> Result<(), MatterError> {
596 let raw = b"0123456789abcdef";
598 let salt = Salter::new(Some(raw), None, None)?.qb64();
599
600 let creator = SaltyCreator::new(Some(&salt), None, None)?;
601
602 let signers1 =
604 creator.create_with_options(None, 1, mtr_dex::ED25519_SEED, 0, 0, 0, true, false);
605 let signers2 =
606 creator.create_with_options(None, 1, mtr_dex::ED25519_SEED, 1, 0, 0, true, false);
607 let signers3 =
608 creator.create_with_options(None, 1, mtr_dex::ED25519_SEED, 0, 1, 0, true, false);
609 let signers4 =
610 creator.create_with_options(None, 1, mtr_dex::ED25519_SEED, 0, 0, 1, true, false);
611
612 let key1 = signers1[0].qb64();
614 let key2 = signers2[0].qb64();
615 let key3 = signers3[0].qb64();
616 let key4 = signers4[0].qb64();
617
618 assert_ne!(key1, key2);
619 assert_ne!(key1, key3);
620 assert_ne!(key1, key4);
621 assert_ne!(key2, key3);
622 assert_ne!(key2, key4);
623 assert_ne!(key3, key4);
624
625 Ok(())
626 }
627
628 #[test]
629 fn test_creator_defaults() -> Result<(), MatterError> {
630 let randy = RandyCreator::default();
632 assert_eq!(randy.salt(), "");
633
634 let creatory = Creatory::default();
635 let creator = creatory.make(None, None, None)?;
636
637 assert!(!creator.salt().is_empty());
639 assert_eq!(creator.stem(), "");
640 assert_eq!(creator.tier(), Some(&Tiers::LOW));
641
642 Ok(())
643 }
644}