cdk 0.8.0

Core Cashu Development Kit library implementing the Cashu protocol
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

use std::collections::HashSet;

use tracing::instrument;

use super::{CheckStateRequest, CheckStateResponse, Mint, ProofState, PublicKey, State};
use crate::{cdk_database, Error};

impl Mint {
    /// Check state
    #[instrument(skip_all)]
    pub async fn check_state(
        &self,
        check_state: &CheckStateRequest,
    ) -> Result<CheckStateResponse, Error> {
        let states = self.localstore.get_proofs_states(&check_state.ys).await?;

        let states = states
            .iter()
            .zip(&check_state.ys)
            .map(|(state, y)| {
                let state = match state {
                    Some(state) => *state,
                    None => State::Unspent,
                };

                ProofState {
                    y: *y,
                    state,
                    witness: None,
                }
            })
            .collect();

        Ok(CheckStateResponse { states })
    }

    /// Check Tokens are not spent or pending
    #[instrument(skip_all)]
    pub async fn check_ys_spendable(
        &self,
        ys: &[PublicKey],
        proof_state: State,
    ) -> Result<(), Error> {
        let original_proofs_state =
            match self.localstore.update_proofs_states(ys, proof_state).await {
                Ok(states) => states,
                Err(cdk_database::Error::AttemptUpdateSpentProof)
                | Err(cdk_database::Error::AttemptRemoveSpentProof) => {
                    return Err(Error::TokenAlreadySpent)
                }
                Err(err) => return Err(err.into()),
            };

        let proofs_state = original_proofs_state
            .iter()
            .flatten()
            .collect::<HashSet<&State>>();

        if proofs_state.contains(&State::Pending) {
            // Reset states before returning error
            for (y, state) in ys.iter().zip(original_proofs_state.iter()) {
                if let Some(original_state) = state {
                    self.localstore
                        .update_proofs_states(&[*y], *original_state)
                        .await?;
                }
            }
            return Err(Error::TokenPending);
        }

        if proofs_state.contains(&State::Spent) {
            // Reset states before returning error
            for (y, state) in ys.iter().zip(original_proofs_state.iter()) {
                if let Some(original_state) = state {
                    self.localstore
                        .update_proofs_states(&[*y], *original_state)
                        .await?;
                }
            }
            return Err(Error::TokenAlreadySpent);
        }

        for public_key in ys {
            tracing::debug!("proof: {} set to {}", public_key.to_hex(), proof_state);
            self.pubsub_manager.proof_state((*public_key, proof_state));
        }

        Ok(())
    }
}