ratify_protocol/v2/reference/
challenges.rs1use std::collections::BTreeMap;
9use std::sync::{Mutex, MutexGuard};
10
11use crate::v2::challenge_issuance::V2ChallengeIssuanceStore;
12use crate::v2::claim_store::V2StoreError;
13use crate::v2::context::V2Context;
14use crate::v2::operation_context::challenge_claim_digest_v2;
15use crate::v2::preflight::ExpectedChallengeV2;
16
17pub const ERR_PERSIST_FAILED: &str = "v2reference: scripted issuance persistence failure";
19
20#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
22pub enum PersistFault {
23 #[default]
25 Ok,
26 FailBeforeCommit,
28 FailAfterCommit,
31}
32
33struct State {
34 records: BTreeMap<String, ExpectedChallengeV2>,
35 fault: PersistFault,
36}
37
38pub struct TestOnlyChallengeIssuanceStore {
40 state: Mutex<State>,
41}
42
43impl std::fmt::Debug for TestOnlyChallengeIssuanceStore {
44 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
45 f.debug_struct("TestOnlyChallengeIssuanceStore")
46 .field("records", &self.len())
47 .finish()
48 }
49}
50
51impl Default for TestOnlyChallengeIssuanceStore {
52 fn default() -> Self {
53 Self::new()
54 }
55}
56
57pub(crate) fn issuance_key(namespace: &str, epoch: i64, digest: &[u8]) -> String {
58 format!("{}:{}|{}|{}", namespace.len(), namespace, epoch, hex::encode(digest))
59}
60
61impl TestOnlyChallengeIssuanceStore {
62 pub fn new() -> Self {
64 TestOnlyChallengeIssuanceStore {
65 state: Mutex::new(State {
66 records: BTreeMap::new(),
67 fault: PersistFault::Ok,
68 }),
69 }
70 }
71
72 fn lock(&self) -> MutexGuard<'_, State> {
73 self.state.lock().unwrap_or_else(|poisoned| poisoned.into_inner())
74 }
75
76 pub fn fail_next_persist(&self, fault: PersistFault) {
78 self.lock().fault = fault;
79 }
80
81 pub fn len(&self) -> usize {
83 self.lock().records.len()
84 }
85
86 pub fn is_empty(&self) -> bool {
88 self.len() == 0
89 }
90
91 pub(crate) fn records(&self) -> BTreeMap<String, ExpectedChallengeV2> {
94 self.lock().records.clone()
95 }
96
97 pub(crate) fn set_records(&self, records: BTreeMap<String, ExpectedChallengeV2>) {
99 self.lock().records = records;
100 }
101}
102
103impl V2ChallengeIssuanceStore for TestOnlyChallengeIssuanceStore {
104 fn persist_v2_challenge(&self, _ctx: &V2Context, record: ExpectedChallengeV2) -> Result<(), V2StoreError> {
106 let mut s = self.lock();
107 let fault = std::mem::take(&mut s.fault);
108 if fault == PersistFault::FailBeforeCommit {
109 return Err(V2StoreError::Unavailable(ERR_PERSIST_FAILED.into()));
110 }
111 let digest = challenge_claim_digest_v2(&record.value)?;
112 let key = issuance_key(&record.verifier_namespace, record.replay_epoch, &digest);
113 if s.records.contains_key(&key) {
114 return Err(V2StoreError::ChallengeIssuanceConflict);
115 }
116 s.records.insert(key, record);
117 if fault == PersistFault::FailAfterCommit {
118 return Err(V2StoreError::Unavailable(ERR_PERSIST_FAILED.into()));
119 }
120 Ok(())
121 }
122
123 fn load_v2_challenge(
124 &self,
125 _ctx: &V2Context,
126 namespace: &str,
127 replay_epoch: i64,
128 claim_digest: &[u8],
129 ) -> Result<ExpectedChallengeV2, V2StoreError> {
130 self.lock()
131 .records
132 .get(&issuance_key(namespace, replay_epoch, claim_digest))
133 .cloned()
134 .ok_or(V2StoreError::ChallengeIssuanceNotFound)
135 }
136}