cashu/nuts/nut00/
token.rs

1//! Cashu Token
2//!
3//! <https://github.com/cashubtc/nuts/blob/main/00.md>
4
5use std::collections::{BTreeSet, HashMap, HashSet};
6use std::fmt;
7use std::str::FromStr;
8
9use bitcoin::base64::engine::{general_purpose, GeneralPurpose};
10use bitcoin::base64::{alphabet, Engine as _};
11use bitcoin::hashes::sha256;
12use serde::{Deserialize, Serialize};
13
14use super::{Error, Proof, ProofV3, ProofV4, Proofs};
15use crate::mint_url::MintUrl;
16use crate::nut02::ShortKeysetId;
17use crate::nuts::nut11::SpendingConditions;
18use crate::nuts::{CurrencyUnit, Id, Kind, PublicKey};
19use crate::{ensure_cdk, Amount, KeySetInfo};
20
21/// Token Enum
22#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
23#[serde(untagged)]
24pub enum Token {
25    /// Token V3
26    TokenV3(TokenV3),
27    /// Token V4
28    TokenV4(TokenV4),
29}
30
31impl fmt::Display for Token {
32    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
33        let token = match self {
34            Self::TokenV3(token) => token.to_string(),
35            Self::TokenV4(token) => token.to_string(),
36        };
37
38        write!(f, "{token}")
39    }
40}
41
42impl Token {
43    /// Create new [`Token`]
44    pub fn new(
45        mint_url: MintUrl,
46        proofs: Proofs,
47        memo: Option<String>,
48        unit: CurrencyUnit,
49    ) -> Self {
50        let proofs = proofs
51            .into_iter()
52            .fold(HashMap::new(), |mut acc, val| {
53                acc.entry(val.keyset_id)
54                    .and_modify(|p: &mut Vec<Proof>| p.push(val.clone()))
55                    .or_insert(vec![val.clone()]);
56                acc
57            })
58            .into_iter()
59            .map(|(id, proofs)| TokenV4Token::new(id, proofs))
60            .collect();
61
62        Token::TokenV4(TokenV4 {
63            mint_url,
64            unit,
65            memo,
66            token: proofs,
67        })
68    }
69
70    /// Proofs in [`Token`]
71    pub fn proofs(&self, mint_keysets: &[KeySetInfo]) -> Result<Proofs, Error> {
72        match self {
73            Self::TokenV3(token) => token.proofs(mint_keysets),
74            Self::TokenV4(token) => token.proofs(mint_keysets),
75        }
76    }
77
78    /// Total value of [`Token`]
79    pub fn value(&self) -> Result<Amount, Error> {
80        match self {
81            Self::TokenV3(token) => token.value(),
82            Self::TokenV4(token) => token.value(),
83        }
84    }
85
86    /// [`Token`] memo
87    pub fn memo(&self) -> &Option<String> {
88        match self {
89            Self::TokenV3(token) => token.memo(),
90            Self::TokenV4(token) => token.memo(),
91        }
92    }
93
94    /// Unit
95    pub fn unit(&self) -> Option<CurrencyUnit> {
96        match self {
97            Self::TokenV3(token) => token.unit().clone(),
98            Self::TokenV4(token) => Some(token.unit().clone()),
99        }
100    }
101
102    /// Mint url
103    pub fn mint_url(&self) -> Result<MintUrl, Error> {
104        match self {
105            Self::TokenV3(token) => {
106                let mint_urls = token.mint_urls();
107
108                ensure_cdk!(mint_urls.len() == 1, Error::UnsupportedToken);
109
110                mint_urls.first().ok_or(Error::UnsupportedToken).cloned()
111            }
112            Self::TokenV4(token) => Ok(token.mint_url.clone()),
113        }
114    }
115
116    /// To v3 string
117    pub fn to_v3_string(&self) -> String {
118        let v3_token = match self {
119            Self::TokenV3(token) => token.clone(),
120            Self::TokenV4(token) => token.clone().into(),
121        };
122
123        v3_token.to_string()
124    }
125
126    /// Serialize the token to raw binary
127    pub fn to_raw_bytes(&self) -> Result<Vec<u8>, Error> {
128        match self {
129            Self::TokenV3(_) => Err(Error::UnsupportedToken),
130            Self::TokenV4(token) => token.to_raw_bytes(),
131        }
132    }
133
134    /// Return all proof secrets in this token without keyset-id mapping, across V3/V4
135    /// This is intended for spending-condition inspection where only the secret matters.
136    pub fn token_secrets(&self) -> Vec<&crate::secret::Secret> {
137        match self {
138            Token::TokenV3(t) => t
139                .token
140                .iter()
141                .flat_map(|kt| kt.proofs.iter().map(|p| &p.secret))
142                .collect(),
143            Token::TokenV4(t) => t
144                .token
145                .iter()
146                .flat_map(|kt| kt.proofs.iter().map(|p| &p.secret))
147                .collect(),
148        }
149    }
150
151    /// Extract unique spending conditions across all proofs
152    pub fn spending_conditions(&self) -> Result<HashSet<SpendingConditions>, Error> {
153        let mut set = HashSet::new();
154        for secret in self.token_secrets().into_iter() {
155            if let Ok(cond) = SpendingConditions::try_from(secret) {
156                set.insert(cond);
157            }
158        }
159        Ok(set)
160    }
161
162    /// Collect pubkeys for P2PK-locked ecash
163    pub fn p2pk_pubkeys(&self) -> Result<HashSet<PublicKey>, Error> {
164        let mut keys: HashSet<PublicKey> = HashSet::new();
165        for secret in self.token_secrets().into_iter() {
166            if let Ok(cond) = SpendingConditions::try_from(secret) {
167                if cond.kind() == Kind::P2PK {
168                    if let Some(ps) = cond.pubkeys() {
169                        keys.extend(ps);
170                    }
171                }
172            }
173        }
174        Ok(keys)
175    }
176
177    /// Collect refund pubkeys from P2PK conditions
178    pub fn p2pk_refund_pubkeys(&self) -> Result<HashSet<PublicKey>, Error> {
179        let mut keys: HashSet<PublicKey> = HashSet::new();
180        for secret in self.token_secrets().into_iter() {
181            if let Ok(cond) = SpendingConditions::try_from(secret) {
182                if cond.kind() == Kind::P2PK {
183                    if let Some(ps) = cond.refund_keys() {
184                        keys.extend(ps);
185                    }
186                }
187            }
188        }
189        Ok(keys)
190    }
191
192    /// Collect HTLC hashes
193    pub fn htlc_hashes(&self) -> Result<HashSet<sha256::Hash>, Error> {
194        let mut hashes: HashSet<sha256::Hash> = HashSet::new();
195        for secret in self.token_secrets().into_iter() {
196            if let Ok(SpendingConditions::HTLCConditions { data, .. }) =
197                SpendingConditions::try_from(secret)
198            {
199                hashes.insert(data);
200            }
201        }
202        Ok(hashes)
203    }
204
205    /// Collect unique locktimes from spending conditions
206    pub fn locktimes(&self) -> Result<BTreeSet<u64>, Error> {
207        let mut set: BTreeSet<u64> = BTreeSet::new();
208        for secret in self.token_secrets().into_iter() {
209            if let Ok(cond) = SpendingConditions::try_from(secret) {
210                if let Some(lt) = cond.locktime() {
211                    set.insert(lt);
212                }
213            }
214        }
215        Ok(set)
216    }
217}
218
219impl FromStr for Token {
220    type Err = Error;
221
222    fn from_str(s: &str) -> Result<Self, Self::Err> {
223        let (is_v3, s) = match (s.strip_prefix("cashuA"), s.strip_prefix("cashuB")) {
224            (Some(s), None) => (true, s),
225            (None, Some(s)) => (false, s),
226            _ => return Err(Error::UnsupportedToken),
227        };
228
229        let decode_config = general_purpose::GeneralPurposeConfig::new()
230            .with_decode_padding_mode(bitcoin::base64::engine::DecodePaddingMode::Indifferent);
231        let decoded = GeneralPurpose::new(&alphabet::URL_SAFE, decode_config).decode(s)?;
232
233        match is_v3 {
234            true => {
235                let decoded_str = String::from_utf8(decoded)?;
236                let token: TokenV3 = serde_json::from_str(&decoded_str)?;
237                Ok(Token::TokenV3(token))
238            }
239            false => {
240                let token: TokenV4 = ciborium::from_reader(&decoded[..])?;
241                Ok(Token::TokenV4(token))
242            }
243        }
244    }
245}
246
247impl TryFrom<&Vec<u8>> for Token {
248    type Error = Error;
249
250    fn try_from(bytes: &Vec<u8>) -> Result<Self, Self::Error> {
251        ensure_cdk!(bytes.len() >= 5, Error::UnsupportedToken);
252
253        let prefix = String::from_utf8(bytes[..5].to_vec())?;
254
255        match prefix.as_str() {
256            "crawB" => {
257                let token: TokenV4 = ciborium::from_reader(&bytes[5..])?;
258                Ok(Token::TokenV4(token))
259            }
260            _ => Err(Error::UnsupportedToken),
261        }
262    }
263}
264
265/// Token V3 Token
266#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
267pub struct TokenV3Token {
268    /// Url of mint
269    pub mint: MintUrl,
270    /// [`Vec<ProofV3>`]
271    pub proofs: Vec<ProofV3>,
272}
273
274impl TokenV3Token {
275    /// Create new [`TokenV3Token`]
276    pub fn new(mint_url: MintUrl, proofs: Proofs) -> Self {
277        Self {
278            mint: mint_url,
279            proofs: proofs.into_iter().map(ProofV3::from).collect(),
280        }
281    }
282}
283
284/// Token
285#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
286pub struct TokenV3 {
287    /// Proofs in [`Token`] by mint
288    pub token: Vec<TokenV3Token>,
289    /// Memo for token
290    #[serde(skip_serializing_if = "Option::is_none")]
291    pub memo: Option<String>,
292    /// Token Unit
293    #[serde(skip_serializing_if = "Option::is_none")]
294    pub unit: Option<CurrencyUnit>,
295}
296
297impl TokenV3 {
298    /// Create new [`Token`]
299    pub fn new(
300        mint_url: MintUrl,
301        proofs: Proofs,
302        memo: Option<String>,
303        unit: Option<CurrencyUnit>,
304    ) -> Result<Self, Error> {
305        ensure_cdk!(!proofs.is_empty(), Error::ProofsRequired);
306
307        Ok(Self {
308            token: vec![TokenV3Token::new(mint_url, proofs)],
309            memo,
310            unit,
311        })
312    }
313
314    /// Proofs
315    pub fn proofs(&self, mint_keysets: &[KeySetInfo]) -> Result<Proofs, Error> {
316        let mut proofs: Proofs = vec![];
317        for t in self.token.iter() {
318            for p in t.proofs.iter() {
319                let long_id = Id::from_short_keyset_id(&p.keyset_id, mint_keysets)?;
320                proofs.push(p.into_proof(&long_id));
321            }
322        }
323        Ok(proofs)
324    }
325
326    /// Value - errors if duplicate proofs are found
327    #[inline]
328    pub fn value(&self) -> Result<Amount, Error> {
329        let proofs: Vec<ProofV3> = self.token.iter().flat_map(|t| t.proofs.clone()).collect();
330        let unique_count = proofs
331            .iter()
332            .collect::<std::collections::HashSet<_>>()
333            .len();
334
335        // Check if there are any duplicate proofs
336        if unique_count != proofs.len() {
337            return Err(Error::DuplicateProofs);
338        }
339
340        Ok(Amount::try_sum(
341            self.token
342                .iter()
343                .map(|t| Amount::try_sum(t.proofs.iter().map(|p| p.amount)))
344                .collect::<Result<Vec<Amount>, _>>()?,
345        )?)
346    }
347
348    /// Memo
349    #[inline]
350    pub fn memo(&self) -> &Option<String> {
351        &self.memo
352    }
353
354    /// Unit
355    #[inline]
356    pub fn unit(&self) -> &Option<CurrencyUnit> {
357        &self.unit
358    }
359
360    /// Mint Url
361    pub fn mint_urls(&self) -> Vec<MintUrl> {
362        let mut mint_urls = Vec::new();
363
364        for token in self.token.iter() {
365            mint_urls.push(token.mint.clone());
366        }
367
368        mint_urls
369    }
370
371    /// Checks if a token has multiple mints
372    ///
373    /// These tokens are not supported by this crate
374    pub fn is_multi_mint(&self) -> bool {
375        self.token.len() > 1
376    }
377}
378
379impl FromStr for TokenV3 {
380    type Err = Error;
381
382    fn from_str(s: &str) -> Result<Self, Self::Err> {
383        let s = s.strip_prefix("cashuA").ok_or(Error::UnsupportedToken)?;
384
385        let decode_config = general_purpose::GeneralPurposeConfig::new()
386            .with_decode_padding_mode(bitcoin::base64::engine::DecodePaddingMode::Indifferent);
387        let decoded = GeneralPurpose::new(&alphabet::URL_SAFE, decode_config).decode(s)?;
388        let decoded_str = String::from_utf8(decoded)?;
389        let token: TokenV3 = serde_json::from_str(&decoded_str)?;
390        Ok(token)
391    }
392}
393
394impl fmt::Display for TokenV3 {
395    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
396        let json_string = serde_json::to_string(self).map_err(|_| fmt::Error)?;
397        let encoded = general_purpose::URL_SAFE.encode(json_string);
398        write!(f, "cashuA{encoded}")
399    }
400}
401
402impl From<TokenV4> for TokenV3 {
403    fn from(token: TokenV4) -> Self {
404        let proofs: Vec<ProofV3> = token
405            .token
406            .into_iter()
407            .flat_map(|token| {
408                token.proofs.into_iter().map(move |p| ProofV3 {
409                    amount: p.amount,
410                    keyset_id: token.keyset_id.clone(),
411                    secret: p.secret,
412                    c: p.c,
413                    witness: p.witness,
414                    dleq: p.dleq,
415                })
416            })
417            .collect();
418
419        let token_v3_token = TokenV3Token {
420            mint: token.mint_url,
421            proofs,
422        };
423        TokenV3 {
424            token: vec![token_v3_token],
425            memo: token.memo,
426            unit: Some(token.unit),
427        }
428    }
429}
430
431/// Token V4
432#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
433pub struct TokenV4 {
434    /// Mint Url
435    #[serde(rename = "m")]
436    pub mint_url: MintUrl,
437    /// Token Unit
438    #[serde(rename = "u")]
439    pub unit: CurrencyUnit,
440    /// Memo for token
441    #[serde(rename = "d", skip_serializing_if = "Option::is_none")]
442    pub memo: Option<String>,
443    /// Proofs grouped by keyset_id
444    #[serde(rename = "t")]
445    pub token: Vec<TokenV4Token>,
446}
447
448impl TokenV4 {
449    /// Proofs from token
450    pub fn proofs(&self, mint_keysets: &[KeySetInfo]) -> Result<Proofs, Error> {
451        let mut proofs: Proofs = vec![];
452        for t in self.token.iter() {
453            let long_id = Id::from_short_keyset_id(&t.keyset_id, mint_keysets)?;
454            proofs.extend(t.proofs.iter().map(|p| p.into_proof(&long_id)));
455        }
456        Ok(proofs)
457    }
458
459    /// Value - errors if duplicate proofs are found
460    #[inline]
461    pub fn value(&self) -> Result<Amount, Error> {
462        let proofs: Vec<ProofV4> = self.token.iter().flat_map(|t| t.proofs.clone()).collect();
463        let unique_count = proofs
464            .iter()
465            .collect::<std::collections::HashSet<_>>()
466            .len();
467
468        // Check if there are any duplicate proofs
469        if unique_count != proofs.len() {
470            return Err(Error::DuplicateProofs);
471        }
472
473        Ok(Amount::try_sum(
474            self.token
475                .iter()
476                .map(|t| Amount::try_sum(t.proofs.iter().map(|p| p.amount)))
477                .collect::<Result<Vec<Amount>, _>>()?,
478        )?)
479    }
480
481    /// Memo
482    #[inline]
483    pub fn memo(&self) -> &Option<String> {
484        &self.memo
485    }
486
487    /// Unit
488    #[inline]
489    pub fn unit(&self) -> &CurrencyUnit {
490        &self.unit
491    }
492
493    /// Serialize the token to raw binary
494    pub fn to_raw_bytes(&self) -> Result<Vec<u8>, Error> {
495        let mut prefix = b"crawB".to_vec();
496        let mut data = Vec::new();
497        ciborium::into_writer(self, &mut data).map_err(Error::CiboriumSerError)?;
498        prefix.extend(data);
499        Ok(prefix)
500    }
501}
502
503impl fmt::Display for TokenV4 {
504    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
505        use serde::ser::Error;
506        let mut data = Vec::new();
507        ciborium::into_writer(self, &mut data).map_err(|e| fmt::Error::custom(e.to_string()))?;
508        let encoded = general_purpose::URL_SAFE.encode(data);
509        write!(f, "cashuB{encoded}")
510    }
511}
512
513impl FromStr for TokenV4 {
514    type Err = Error;
515
516    fn from_str(s: &str) -> Result<Self, Self::Err> {
517        let s = s.strip_prefix("cashuB").ok_or(Error::UnsupportedToken)?;
518
519        let decode_config = general_purpose::GeneralPurposeConfig::new()
520            .with_decode_padding_mode(bitcoin::base64::engine::DecodePaddingMode::Indifferent);
521        let decoded = GeneralPurpose::new(&alphabet::URL_SAFE, decode_config).decode(s)?;
522        let token: TokenV4 = ciborium::from_reader(&decoded[..])?;
523        Ok(token)
524    }
525}
526
527impl TryFrom<&Vec<u8>> for TokenV4 {
528    type Error = Error;
529
530    fn try_from(bytes: &Vec<u8>) -> Result<Self, Self::Error> {
531        ensure_cdk!(bytes.len() >= 5, Error::UnsupportedToken);
532
533        let prefix = String::from_utf8(bytes[..5].to_vec())?;
534        ensure_cdk!(prefix.as_str() == "crawB", Error::UnsupportedToken);
535
536        Ok(ciborium::from_reader(&bytes[5..])?)
537    }
538}
539
540impl TryFrom<TokenV3> for TokenV4 {
541    type Error = Error;
542    fn try_from(token: TokenV3) -> Result<Self, Self::Error> {
543        let mint_urls = token.mint_urls();
544        let proofs: Vec<ProofV3> = token.token.into_iter().flat_map(|t| t.proofs).collect();
545
546        ensure_cdk!(mint_urls.len() == 1, Error::UnsupportedToken);
547
548        let mint_url = mint_urls.first().ok_or(Error::UnsupportedToken)?;
549
550        let proofs = proofs
551            .into_iter()
552            .fold(
553                HashMap::<ShortKeysetId, Vec<ProofV4>>::new(),
554                |mut acc, val| {
555                    acc.entry(val.keyset_id.clone())
556                        .and_modify(|p: &mut Vec<ProofV4>| p.push(val.clone().into()))
557                        .or_insert(vec![val.clone().into()]);
558                    acc
559                },
560            )
561            .into_iter()
562            .map(|(id, proofs)| TokenV4Token {
563                keyset_id: id,
564                proofs,
565            })
566            .collect();
567
568        Ok(TokenV4 {
569            mint_url: mint_url.clone(),
570            token: proofs,
571            memo: token.memo,
572            unit: token.unit.ok_or(Error::UnsupportedUnit)?,
573        })
574    }
575}
576
577/// Token V4 Token
578#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
579pub struct TokenV4Token {
580    /// `Keyset id`
581    #[serde(
582        rename = "i",
583        serialize_with = "serialize_v4_keyset_id",
584        deserialize_with = "deserialize_v4_keyset_id"
585    )]
586    pub keyset_id: ShortKeysetId,
587    /// Proofs
588    #[serde(rename = "p")]
589    pub proofs: Vec<ProofV4>,
590}
591
592fn serialize_v4_keyset_id<S>(keyset_id: &ShortKeysetId, serializer: S) -> Result<S::Ok, S::Error>
593where
594    S: serde::Serializer,
595{
596    serializer.serialize_bytes(&keyset_id.to_bytes())
597}
598
599fn deserialize_v4_keyset_id<'de, D>(deserializer: D) -> Result<ShortKeysetId, D::Error>
600where
601    D: serde::Deserializer<'de>,
602{
603    let bytes = Vec::<u8>::deserialize(deserializer)?;
604    ShortKeysetId::from_bytes(&bytes).map_err(serde::de::Error::custom)
605}
606
607impl TokenV4Token {
608    /// Create new [`TokenV4Token`]
609    pub fn new(keyset_id: Id, proofs: Proofs) -> Self {
610        // Create a short keyset id from id
611        let short_id = ShortKeysetId::from(keyset_id);
612        Self {
613            keyset_id: short_id,
614            proofs: proofs.into_iter().map(Into::into).collect(),
615        }
616    }
617}
618
619#[cfg(test)]
620mod tests {
621    use std::str::FromStr;
622
623    use bip39::rand::{self, RngCore};
624    use bitcoin::hashes::sha256::Hash as Sha256Hash;
625    use bitcoin::hashes::Hash;
626
627    use super::*;
628    use crate::dhke::hash_to_curve;
629    use crate::mint_url::MintUrl;
630    use crate::nuts::nut11::{Conditions, SigFlag, SpendingConditions};
631    use crate::secret::Secret;
632    use crate::util::hex;
633
634    #[test]
635    fn test_token_padding() {
636        let token_str_with_padding = "cashuAeyJ0b2tlbiI6W3sibWludCI6Imh0dHBzOi8vODMzMy5zcGFjZTozMzM4IiwicHJvb2ZzIjpbeyJhbW91bnQiOjIsImlkIjoiMDA5YTFmMjkzMjUzZTQxZSIsInNlY3JldCI6IjQwNzkxNWJjMjEyYmU2MWE3N2UzZTZkMmFlYjRjNzI3OTgwYmRhNTFjZDA2YTZhZmMyOWUyODYxNzY4YTc4MzciLCJDIjoiMDJiYzkwOTc5OTdkODFhZmIyY2M3MzQ2YjVlNDM0NWE5MzQ2YmQyYTUwNmViNzk1ODU5OGE3MmYwY2Y4NTE2M2VhIn0seyJhbW91bnQiOjgsImlkIjoiMDA5YTFmMjkzMjUzZTQxZSIsInNlY3JldCI6ImZlMTUxMDkzMTRlNjFkNzc1NmIwZjhlZTBmMjNhNjI0YWNhYTNmNGUwNDJmNjE0MzNjNzI4YzcwNTdiOTMxYmUiLCJDIjoiMDI5ZThlNTA1MGI4OTBhN2Q2YzA5NjhkYjE2YmMxZDVkNWZhMDQwZWExZGUyODRmNmVjNjlkNjEyOTlmNjcxMDU5In1dfV0sInVuaXQiOiJzYXQiLCJtZW1vIjoiVGhhbmsgeW91IHZlcnkgbXVjaC4ifQ==";
637
638        let token = TokenV3::from_str(token_str_with_padding).unwrap();
639
640        let token_str_without_padding = "cashuAeyJ0b2tlbiI6W3sibWludCI6Imh0dHBzOi8vODMzMy5zcGFjZTozMzM4IiwicHJvb2ZzIjpbeyJhbW91bnQiOjIsImlkIjoiMDA5YTFmMjkzMjUzZTQxZSIsInNlY3JldCI6IjQwNzkxNWJjMjEyYmU2MWE3N2UzZTZkMmFlYjRjNzI3OTgwYmRhNTFjZDA2YTZhZmMyOWUyODYxNzY4YTc4MzciLCJDIjoiMDJiYzkwOTc5OTdkODFhZmIyY2M3MzQ2YjVlNDM0NWE5MzQ2YmQyYTUwNmViNzk1ODU5OGE3MmYwY2Y4NTE2M2VhIn0seyJhbW91bnQiOjgsImlkIjoiMDA5YTFmMjkzMjUzZTQxZSIsInNlY3JldCI6ImZlMTUxMDkzMTRlNjFkNzc1NmIwZjhlZTBmMjNhNjI0YWNhYTNmNGUwNDJmNjE0MzNjNzI4YzcwNTdiOTMxYmUiLCJDIjoiMDI5ZThlNTA1MGI4OTBhN2Q2YzA5NjhkYjE2YmMxZDVkNWZhMDQwZWExZGUyODRmNmVjNjlkNjEyOTlmNjcxMDU5In1dfV0sInVuaXQiOiJzYXQiLCJtZW1vIjoiVGhhbmsgeW91IHZlcnkgbXVjaC4ifQ";
641
642        let token_without = TokenV3::from_str(token_str_without_padding).unwrap();
643
644        assert_eq!(token, token_without);
645    }
646
647    #[test]
648    fn test_token_v4_str_round_trip() {
649        let token_str = "cashuBpGF0gaJhaUgArSaMTR9YJmFwgaNhYQFhc3hAOWE2ZGJiODQ3YmQyMzJiYTc2ZGIwZGYxOTcyMTZiMjlkM2I4Y2MxNDU1M2NkMjc4MjdmYzFjYzk0MmZlZGI0ZWFjWCEDhhhUP_trhpXfStS6vN6So0qWvc2X3O4NfM-Y1HISZ5JhZGlUaGFuayB5b3VhbXVodHRwOi8vbG9jYWxob3N0OjMzMzhhdWNzYXQ=";
650        let token = TokenV4::from_str(token_str).unwrap();
651
652        assert_eq!(
653            token.mint_url,
654            MintUrl::from_str("http://localhost:3338").unwrap()
655        );
656        assert_eq!(
657            token.token[0].keyset_id,
658            ShortKeysetId::from_str("00ad268c4d1f5826").unwrap()
659        );
660
661        let encoded = &token.to_string();
662
663        let token_data = TokenV4::from_str(encoded).unwrap();
664
665        assert_eq!(token_data, token);
666    }
667
668    #[test]
669    fn test_token_v4_multi_keyset() {
670        let token_str_multi_keysets = "cashuBo2F0gqJhaUgA_9SLj17PgGFwgaNhYQFhc3hAYWNjMTI0MzVlN2I4NDg0YzNjZjE4NTAxNDkyMThhZjkwZjcxNmE1MmJmNGE1ZWQzNDdlNDhlY2MxM2Y3NzM4OGFjWCECRFODGd5IXVW-07KaZCvuWHk3WrnnpiDhHki6SCQh88-iYWlIAK0mjE0fWCZhcIKjYWECYXN4QDEzMjNkM2Q0NzA3YTU4YWQyZTIzYWRhNGU5ZjFmNDlmNWE1YjRhYzdiNzA4ZWIwZDYxZjczOGY0ODMwN2U4ZWVhY1ghAjRWqhENhLSsdHrr2Cw7AFrKUL9Ffr1XN6RBT6w659lNo2FhAWFzeEA1NmJjYmNiYjdjYzY0MDZiM2ZhNWQ1N2QyMTc0ZjRlZmY4YjQ0MDJiMTc2OTI2ZDNhNTdkM2MzZGNiYjU5ZDU3YWNYIQJzEpxXGeWZN5qXSmJjY8MzxWyvwObQGr5G1YCCgHicY2FtdWh0dHA6Ly9sb2NhbGhvc3Q6MzMzOGF1Y3NhdA==";
671
672        let token = Token::from_str(token_str_multi_keysets).unwrap();
673        let amount = token.value().expect("valid amount");
674
675        assert_eq!(amount, Amount::from(4));
676
677        let unit = token.unit().unwrap();
678        assert_eq!(CurrencyUnit::Sat, unit);
679
680        match token {
681            Token::TokenV4(token) => {
682                let tokens: Vec<ShortKeysetId> =
683                    token.token.iter().map(|t| t.keyset_id.clone()).collect();
684
685                assert_eq!(tokens.len(), 2);
686
687                assert!(tokens.contains(&ShortKeysetId::from_str("00ffd48b8f5ecf80").unwrap()));
688                assert!(tokens.contains(&ShortKeysetId::from_str("00ad268c4d1f5826").unwrap()));
689
690                let mint_url = token.mint_url;
691
692                assert_eq!("http://localhost:3338", &mint_url.to_string());
693            }
694            _ => {
695                panic!("Token should be a v4 token")
696            }
697        }
698    }
699
700    #[test]
701    fn test_tokenv4_from_tokenv3() {
702        let token_v3_str = "cashuAeyJ0b2tlbiI6W3sibWludCI6Imh0dHBzOi8vODMzMy5zcGFjZTozMzM4IiwicHJvb2ZzIjpbeyJhbW91bnQiOjIsImlkIjoiMDA5YTFmMjkzMjUzZTQxZSIsInNlY3JldCI6IjQwNzkxNWJjMjEyYmU2MWE3N2UzZTZkMmFlYjRjNzI3OTgwYmRhNTFjZDA2YTZhZmMyOWUyODYxNzY4YTc4MzciLCJDIjoiMDJiYzkwOTc5OTdkODFhZmIyY2M3MzQ2YjVlNDM0NWE5MzQ2YmQyYTUwNmViNzk1ODU5OGE3MmYwY2Y4NTE2M2VhIn0seyJhbW91bnQiOjgsImlkIjoiMDA5YTFmMjkzMjUzZTQxZSIsInNlY3JldCI6ImZlMTUxMDkzMTRlNjFkNzc1NmIwZjhlZTBmMjNhNjI0YWNhYTNmNGUwNDJmNjE0MzNjNzI4YzcwNTdiOTMxYmUiLCJDIjoiMDI5ZThlNTA1MGI4OTBhN2Q2YzA5NjhkYjE2YmMxZDVkNWZhMDQwZWExZGUyODRmNmVjNjlkNjEyOTlmNjcxMDU5In1dfV0sInVuaXQiOiJzYXQiLCJtZW1vIjoiVGhhbmsgeW91LiJ9";
703        let token_v3 =
704            TokenV3::from_str(token_v3_str).expect("TokenV3 should be created from string");
705        let token_v4 = TokenV4::try_from(token_v3).expect("TokenV3 should be converted to TokenV4");
706        let token_v4_expected = "cashuBpGFtd2h0dHBzOi8vODMzMy5zcGFjZTozMzM4YXVjc2F0YWRqVGhhbmsgeW91LmF0gaJhaUgAmh8pMlPkHmFwgqRhYQJhc3hANDA3OTE1YmMyMTJiZTYxYTc3ZTNlNmQyYWViNGM3Mjc5ODBiZGE1MWNkMDZhNmFmYzI5ZTI4NjE3NjhhNzgzN2FjWCECvJCXmX2Br7LMc0a15DRak0a9KlBut5WFmKcvDPhRY-phZPakYWEIYXN4QGZlMTUxMDkzMTRlNjFkNzc1NmIwZjhlZTBmMjNhNjI0YWNhYTNmNGUwNDJmNjE0MzNjNzI4YzcwNTdiOTMxYmVhY1ghAp6OUFC4kKfWwJaNsWvB1dX6BA6h3ihPbsadYSmfZxBZYWT2";
707        assert_eq!(token_v4.to_string(), token_v4_expected);
708    }
709
710    #[test]
711    fn test_token_str_round_trip() {
712        let token_str = "cashuAeyJ0b2tlbiI6W3sibWludCI6Imh0dHBzOi8vODMzMy5zcGFjZTozMzM4IiwicHJvb2ZzIjpbeyJhbW91bnQiOjIsImlkIjoiMDA5YTFmMjkzMjUzZTQxZSIsInNlY3JldCI6IjQwNzkxNWJjMjEyYmU2MWE3N2UzZTZkMmFlYjRjNzI3OTgwYmRhNTFjZDA2YTZhZmMyOWUyODYxNzY4YTc4MzciLCJDIjoiMDJiYzkwOTc5OTdkODFhZmIyY2M3MzQ2YjVlNDM0NWE5MzQ2YmQyYTUwNmViNzk1ODU5OGE3MmYwY2Y4NTE2M2VhIn0seyJhbW91bnQiOjgsImlkIjoiMDA5YTFmMjkzMjUzZTQxZSIsInNlY3JldCI6ImZlMTUxMDkzMTRlNjFkNzc1NmIwZjhlZTBmMjNhNjI0YWNhYTNmNGUwNDJmNjE0MzNjNzI4YzcwNTdiOTMxYmUiLCJDIjoiMDI5ZThlNTA1MGI4OTBhN2Q2YzA5NjhkYjE2YmMxZDVkNWZhMDQwZWExZGUyODRmNmVjNjlkNjEyOTlmNjcxMDU5In1dfV0sInVuaXQiOiJzYXQiLCJtZW1vIjoiVGhhbmsgeW91LiJ9";
713
714        let token = TokenV3::from_str(token_str).unwrap();
715        assert_eq!(
716            token.token[0].mint,
717            MintUrl::from_str("https://8333.space:3338").unwrap()
718        );
719        assert_eq!(
720            token.token[0].proofs[0].clone().keyset_id,
721            ShortKeysetId::from_str("009a1f293253e41e").unwrap()
722        );
723        assert_eq!(token.unit.clone().unwrap(), CurrencyUnit::Sat);
724
725        let encoded = &token.to_string();
726
727        let token_data = TokenV3::from_str(encoded).unwrap();
728
729        assert_eq!(token_data, token);
730    }
731
732    #[test]
733    fn incorrect_tokens() {
734        let incorrect_prefix = "casshuAeyJ0b2tlbiI6W3sibWludCI6Imh0dHBzOi8vODMzMy5zcGFjZTozMzM4IiwicHJvb2ZzIjpbeyJhbW91bnQiOjIsImlkIjoiMDA5YTFmMjkzMjUzZTQxZSIsInNlY3JldCI6IjQwNzkxNWJjMjEyYmU2MWE3N2UzZTZkMmFlYjRjNzI3OTgwYmRhNTFjZDA2YTZhZmMyOWUyODYxNzY4YTc4MzciLCJDIjoiMDJiYzkwOTc5OTdkODFhZmIyY2M3MzQ2YjVlNDM0NWE5MzQ2YmQyYTUwNmViNzk1ODU5OGE3MmYwY2Y4NTE2M2VhIn0seyJhbW91bnQiOjgsImlkIjoiMDA5YTFmMjkzMjUzZTQxZSIsInNlY3JldCI6ImZlMTUxMDkzMTRlNjFkNzc1NmIwZjhlZTBmMjNhNjI0YWNhYTNmNGUwNDJmNjE0MzNjNzI4YzcwNTdiOTMxYmUiLCJDIjoiMDI5ZThlNTA1MGI4OTBhN2Q2YzA5NjhkYjE2YmMxZDVkNWZhMDQwZWExZGUyODRmNmVjNjlkNjEyOTlmNjcxMDU5In1dfV0sInVuaXQiOiJzYXQiLCJtZW1vIjoiVGhhbmsgeW91LiJ9";
735
736        let incorrect_prefix_token = TokenV3::from_str(incorrect_prefix);
737
738        assert!(incorrect_prefix_token.is_err());
739
740        let no_prefix = "eyJ0b2tlbiI6W3sibWludCI6Imh0dHBzOi8vODMzMy5zcGFjZTozMzM4IiwicHJvb2ZzIjpbeyJhbW91bnQiOjIsImlkIjoiMDA5YTFmMjkzMjUzZTQxZSIsInNlY3JldCI6IjQwNzkxNWJjMjEyYmU2MWE3N2UzZTZkMmFlYjRjNzI3OTgwYmRhNTFjZDA2YTZhZmMyOWUyODYxNzY4YTc4MzciLCJDIjoiMDJiYzkwOTc5OTdkODFhZmIyY2M3MzQ2YjVlNDM0NWE5MzQ2YmQyYTUwNmViNzk1ODU5OGE3MmYwY2Y4NTE2M2VhIn0seyJhbW91bnQiOjgsImlkIjoiMDA5YTFmMjkzMjUzZTQxZSIsInNlY3JldCI6ImZlMTUxMDkzMTRlNjFkNzc1NmIwZjhlZTBmMjNhNjI0YWNhYTNmNGUwNDJmNjE0MzNjNzI4YzcwNTdiOTMxYmUiLCJDIjoiMDI5ZThlNTA1MGI4OTBhN2Q2YzA5NjhkYjE2YmMxZDVkNWZhMDQwZWExZGUyODRmNmVjNjlkNjEyOTlmNjcxMDU5In1dfV0sInVuaXQiOiJzYXQiLCJtZW1vIjoiVGhhbmsgeW91LiJ9";
741
742        let no_prefix_token = TokenV3::from_str(no_prefix);
743
744        assert!(no_prefix_token.is_err());
745
746        let correct_token = "cashuAeyJ0b2tlbiI6W3sibWludCI6Imh0dHBzOi8vODMzMy5zcGFjZTozMzM4IiwicHJvb2ZzIjpbeyJhbW91bnQiOjIsImlkIjoiMDA5YTFmMjkzMjUzZTQxZSIsInNlY3JldCI6IjQwNzkxNWJjMjEyYmU2MWE3N2UzZTZkMmFlYjRjNzI3OTgwYmRhNTFjZDA2YTZhZmMyOWUyODYxNzY4YTc4MzciLCJDIjoiMDJiYzkwOTc5OTdkODFhZmIyY2M3MzQ2YjVlNDM0NWE5MzQ2YmQyYTUwNmViNzk1ODU5OGE3MmYwY2Y4NTE2M2VhIn0seyJhbW91bnQiOjgsImlkIjoiMDA5YTFmMjkzMjUzZTQxZSIsInNlY3JldCI6ImZlMTUxMDkzMTRlNjFkNzc1NmIwZjhlZTBmMjNhNjI0YWNhYTNmNGUwNDJmNjE0MzNjNzI4YzcwNTdiOTMxYmUiLCJDIjoiMDI5ZThlNTA1MGI4OTBhN2Q2YzA5NjhkYjE2YmMxZDVkNWZhMDQwZWExZGUyODRmNmVjNjlkNjEyOTlmNjcxMDU5In1dfV0sInVuaXQiOiJzYXQiLCJtZW1vIjoiVGhhbmsgeW91LiJ9";
747
748        let correct_token = TokenV3::from_str(correct_token);
749
750        assert!(correct_token.is_ok());
751    }
752
753    #[test]
754    fn test_token_v4_raw_roundtrip() {
755        let token_raw = hex::decode("6372617742a4617481a261694800ad268c4d1f5826617081a3616101617378403961366462623834376264323332626137366462306466313937323136623239643362386363313435353363643237383237666331636339343266656462346561635821038618543ffb6b8695df4ad4babcde92a34a96bdcd97dcee0d7ccf98d4721267926164695468616e6b20796f75616d75687474703a2f2f6c6f63616c686f73743a33333338617563736174").unwrap();
756        let token = TokenV4::try_from(&token_raw).expect("Token deserialization error");
757        let token_raw_ = token.to_raw_bytes().expect("Token serialization error");
758        let token_ = TokenV4::try_from(&token_raw_).expect("Token deserialization error");
759        assert!(token_ == token)
760    }
761
762    #[test]
763    fn test_token_generic_raw_roundtrip() {
764        let tokenv4_raw = hex::decode("6372617742a4617481a261694800ad268c4d1f5826617081a3616101617378403961366462623834376264323332626137366462306466313937323136623239643362386363313435353363643237383237666331636339343266656462346561635821038618543ffb6b8695df4ad4babcde92a34a96bdcd97dcee0d7ccf98d4721267926164695468616e6b20796f75616d75687474703a2f2f6c6f63616c686f73743a33333338617563736174").unwrap();
765        let tokenv4 = Token::try_from(&tokenv4_raw).expect("Token deserialization error");
766        let tokenv4_ = TokenV4::try_from(&tokenv4_raw).expect("Token deserialization error");
767        let tokenv4_bytes = tokenv4.to_raw_bytes().expect("Serialization error");
768        let tokenv4_bytes_ = tokenv4_.to_raw_bytes().expect("Serialization error");
769        assert!(tokenv4_bytes_ == tokenv4_bytes);
770    }
771
772    #[test]
773    fn test_token_with_duplicate_proofs() {
774        // Create a token with duplicate proofs
775        let mint_url = MintUrl::from_str("https://example.com").unwrap();
776        let keyset_id = Id::from_str("009a1f293253e41e").unwrap();
777
778        let secret = Secret::generate();
779        // Create two identical proofs
780        let proof1 = Proof {
781            amount: Amount::from(10),
782            keyset_id,
783            secret: secret.clone(),
784            c: "02bc9097997d81afb2cc7346b5e4345a9346bd2a506eb7958598a72f0cf85163ea"
785                .parse()
786                .unwrap(),
787            witness: None,
788            dleq: None,
789        };
790
791        let proof2 = proof1.clone(); // Duplicate proof
792
793        // Create a token with the duplicate proofs
794        let proofs = vec![proof1.clone(), proof2].into_iter().collect();
795        let token = Token::new(mint_url.clone(), proofs, None, CurrencyUnit::Sat);
796
797        // Verify that value() returns an error
798        let result = token.value();
799        assert!(result.is_err());
800
801        // Create a token with unique proofs
802        let proof3 = Proof {
803            amount: Amount::from(10),
804            keyset_id,
805            secret: Secret::generate(),
806            c: "03bc9097997d81afb2cc7346b5e4345a9346bd2a506eb7958598a72f0cf85163ea"
807                .parse()
808                .unwrap(), // Different C value
809            witness: None,
810            dleq: None,
811        };
812
813        let proofs = vec![proof1, proof3].into_iter().collect();
814        let token = Token::new(mint_url, proofs, None, CurrencyUnit::Sat);
815
816        // Verify that value() succeeds with unique proofs
817        let result = token.value();
818        assert!(result.is_ok());
819        assert_eq!(result.unwrap(), Amount::from(20));
820    }
821
822    #[test]
823    fn test_token_from_proofs_with_idv2_round_trip() {
824        let mint_url = MintUrl::from_str("https://example.com").unwrap();
825
826        let keysets_info: Vec<KeySetInfo> = (0..10)
827            .map(|_| {
828                let mut bytes: [u8; 33] = [0u8; 33];
829                bytes[0] = 1u8;
830                rand::thread_rng().fill_bytes(&mut bytes[1..]);
831                let id = Id::from_bytes(&bytes).unwrap();
832                KeySetInfo {
833                    id,
834                    unit: CurrencyUnit::Sat,
835                    active: true,
836                    input_fee_ppk: 0,
837                    final_expiry: None,
838                }
839            })
840            .collect();
841
842        let chosen_keyset_id = keysets_info[0].id;
843        // Make up a bunch of fake proofs
844        let proofs = (0..5)
845            .map(|_| {
846                let mut c_preimage: [u8; 33] = [0u8; 33];
847                c_preimage[0] = 1u8;
848                rand::thread_rng().fill_bytes(&mut c_preimage[1..]);
849                Proof::new(
850                    Amount::from(1),
851                    chosen_keyset_id,
852                    Secret::generate(),
853                    hash_to_curve(&c_preimage).unwrap(),
854                )
855            })
856            .collect();
857
858        let token = Token::new(mint_url.clone(), proofs, None, CurrencyUnit::Sat);
859        let token_str = token.to_string();
860
861        let token1 = Token::from_str(&token_str);
862        assert!(token1.is_ok());
863
864        let proofs1 = token1.unwrap().proofs(&keysets_info);
865        assert!(proofs1.is_ok());
866
867        //println!("{:?}", proofs1);
868    }
869
870    #[test]
871    fn test_token_proofs_with_unknown_short_keyset_id() {
872        let mint_url = MintUrl::from_str("https://example.com").unwrap();
873
874        let keysets_info: Vec<KeySetInfo> = (0..10)
875            .map(|_| {
876                let mut bytes: [u8; 33] = [0u8; 33];
877                bytes[0] = 1u8;
878                rand::thread_rng().fill_bytes(&mut bytes[1..]);
879                let id = Id::from_bytes(&bytes).unwrap();
880                KeySetInfo {
881                    id,
882                    unit: CurrencyUnit::Sat,
883                    active: true,
884                    input_fee_ppk: 0,
885                    final_expiry: None,
886                }
887            })
888            .collect();
889
890        let chosen_keyset_id =
891            Id::from_str("01c352c0b47d42edb764bddf8c53d77b85f057157d92084d9d05e876251ecd8422")
892                .unwrap();
893
894        // Make up a bunch of fake proofs
895        let proofs = (0..5)
896            .map(|_| {
897                let mut c_preimage: [u8; 33] = [0u8; 33];
898                c_preimage[0] = 1u8;
899                rand::thread_rng().fill_bytes(&mut c_preimage[1..]);
900                Proof::new(
901                    Amount::from(1),
902                    chosen_keyset_id,
903                    Secret::generate(),
904                    hash_to_curve(&c_preimage).unwrap(),
905                )
906            })
907            .collect();
908
909        let token = Token::new(mint_url.clone(), proofs, None, CurrencyUnit::Sat);
910        let token_str = token.to_string();
911
912        let token1 = Token::from_str(&token_str);
913        assert!(token1.is_ok());
914
915        let proofs1 = token1.unwrap().proofs(&keysets_info);
916        assert!(proofs1.is_err());
917    }
918    #[test]
919    fn test_token_spending_condition_helpers_p2pk_htlc_v4() {
920        let mint_url = MintUrl::from_str("https://example.com").unwrap();
921        let keyset_id = Id::from_str("009a1f293253e41e").unwrap();
922
923        // P2PK: base pubkey plus an extra pubkey via tags, refund key, and locktime
924        let sk1 = crate::nuts::SecretKey::generate();
925        let pk1 = sk1.public_key();
926        let sk2 = crate::nuts::SecretKey::generate();
927        let pk2 = sk2.public_key();
928        let refund_sk = crate::nuts::SecretKey::generate();
929        let refund_pk = refund_sk.public_key();
930
931        let cond_p2pk = Conditions {
932            locktime: Some(1_700_000_000),
933            pubkeys: Some(vec![pk2]),
934            refund_keys: Some(vec![refund_pk]),
935            num_sigs: Some(1),
936            sig_flag: SigFlag::SigInputs,
937            num_sigs_refund: None,
938        };
939
940        let nut10_p2pk = crate::nuts::Nut10Secret::new(
941            crate::nuts::Kind::P2PK,
942            pk1.to_string(),
943            Some(cond_p2pk.clone()),
944        );
945        let secret_p2pk: Secret = nut10_p2pk.try_into().unwrap();
946
947        // HTLC: use a known preimage hash and its own locktime
948        let preimage = b"cdk-test-preimage";
949        let htlc_hash = Sha256Hash::hash(preimage);
950        let cond_htlc = Conditions {
951            locktime: Some(1_800_000_000),
952            ..Default::default()
953        };
954        let nut10_htlc = crate::nuts::Nut10Secret::new(
955            crate::nuts::Kind::HTLC,
956            htlc_hash.to_string(),
957            Some(cond_htlc.clone()),
958        );
959        let secret_htlc: Secret = nut10_htlc.try_into().unwrap();
960
961        // Build two proofs (one P2PK, one HTLC)
962        let proof_p2pk = Proof::new(Amount::from(1), keyset_id, secret_p2pk.clone(), pk1);
963        let proof_htlc = Proof::new(Amount::from(2), keyset_id, secret_htlc.clone(), pk2);
964        let token = Token::new(
965            mint_url,
966            vec![proof_p2pk, proof_htlc].into_iter().collect(),
967            None,
968            CurrencyUnit::Sat,
969        );
970
971        // token_secrets should see both
972        assert_eq!(token.token_secrets().len(), 2);
973
974        // spending_conditions should contain both kinds with their conditions
975        let sc = token.spending_conditions().unwrap();
976        assert!(sc.contains(&SpendingConditions::P2PKConditions {
977            data: pk1,
978            conditions: Some(cond_p2pk.clone())
979        }));
980        assert!(sc.contains(&SpendingConditions::HTLCConditions {
981            data: htlc_hash,
982            conditions: Some(cond_htlc.clone())
983        }));
984
985        // p2pk_pubkeys should include base pk1 and extra pk2 from tags (deduped)
986        let pks = token.p2pk_pubkeys().unwrap();
987        assert!(pks.contains(&pk1));
988        assert!(pks.contains(&pk2));
989        assert_eq!(pks.len(), 2);
990
991        // p2pk_refund_pubkeys should include refund_pk only
992        let refund = token.p2pk_refund_pubkeys().unwrap();
993        assert!(refund.contains(&refund_pk));
994        assert_eq!(refund.len(), 1);
995
996        // htlc_hashes should include exactly our hash
997        let hashes = token.htlc_hashes().unwrap();
998        assert!(hashes.contains(&htlc_hash));
999        assert_eq!(hashes.len(), 1);
1000
1001        // locktimes should include both unique locktimes
1002        let lts = token.locktimes().unwrap();
1003        assert!(lts.contains(&1_700_000_000));
1004        assert!(lts.contains(&1_800_000_000));
1005        assert_eq!(lts.len(), 2);
1006    }
1007
1008    #[test]
1009    fn test_token_spending_condition_helpers_dedup_and_v3() {
1010        let mint_url = MintUrl::from_str("https://example.org").unwrap();
1011        let id = Id::from_str("00ad268c4d1f5826").unwrap();
1012
1013        // Same P2PK conditions duplicated across two proofs
1014        let sk = crate::nuts::SecretKey::generate();
1015        let pk = sk.public_key();
1016
1017        let cond = Conditions {
1018            locktime: Some(1_650_000_000),
1019            pubkeys: Some(vec![pk]), // include itself to test dedup inside pubkeys()
1020            refund_keys: Some(vec![pk]), // deliberate duplicate
1021            num_sigs: Some(1),
1022            sig_flag: SigFlag::SigInputs,
1023            num_sigs_refund: None,
1024        };
1025
1026        let nut10 = crate::nuts::Nut10Secret::new(
1027            crate::nuts::Kind::P2PK,
1028            pk.to_string(),
1029            Some(cond.clone()),
1030        );
1031        let secret: Secret = nut10.try_into().unwrap();
1032
1033        let p1 = Proof::new(Amount::from(1), id, secret.clone(), pk);
1034        let p2 = Proof::new(Amount::from(2), id, secret.clone(), pk);
1035
1036        // Build a V3 token explicitly and wrap into Token::TokenV3
1037        let token_v3 = TokenV3::new(
1038            mint_url,
1039            vec![p1, p2].into_iter().collect(),
1040            None,
1041            Some(CurrencyUnit::Sat),
1042        )
1043        .unwrap();
1044        let token = Token::TokenV3(token_v3);
1045
1046        // Helpers should dedup
1047        let sc = token.spending_conditions().unwrap();
1048        assert_eq!(sc.len(), 1); // identical conditions across proofs
1049
1050        let pks = token.p2pk_pubkeys().unwrap();
1051        assert!(pks.contains(&pk));
1052        assert_eq!(pks.len(), 1); // duplicates removed
1053
1054        let refunds = token.p2pk_refund_pubkeys().unwrap();
1055        assert!(refunds.contains(&pk));
1056        assert_eq!(refunds.len(), 1);
1057
1058        let lts = token.locktimes().unwrap();
1059        assert!(lts.contains(&1_650_000_000));
1060        assert_eq!(lts.len(), 1);
1061
1062        // No HTLC here
1063        let hashes = token.htlc_hashes().unwrap();
1064        assert!(hashes.is_empty());
1065
1066        // token_secrets length equals number of proofs even if conditions identical
1067        assert_eq!(token.token_secrets().len(), 2);
1068    }
1069}
cashu/nuts/nut00/token.rs

cashu/nuts/nut00/
token.rs
