nym-compact-ecash 1.20.4

Nym's ecash implementation
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
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136

// Copyright 2024 - Nym Technologies SA <contact@nymtech.net>
// SPDX-License-Identifier: Apache-2.0

#[cfg(test)]
mod tests {
    use crate::error::Result;
    use crate::scheme::aggregation::{aggregate_verification_keys, aggregate_wallets};
    use crate::scheme::keygen::{
        generate_keypair_user, ttp_keygen, SecretKeyAuth, VerificationKeyAuth,
    };
    use crate::scheme::withdrawal::{issue, issue_verify, withdrawal_request, WithdrawalRequest};
    use crate::scheme::{PartialWallet, PayInfo, Payment, Wallet};
    use crate::setup::Parameters;
    use crate::tests::helpers::{
        generate_coin_indices_signatures, generate_expiration_date_signatures,
    };
    use itertools::izip;

    #[test]
    fn main() -> Result<()> {
        let total_coins = 32;
        let params = Parameters::new(total_coins);
        // NOTE: Make sure that the date timestamp are calculated at 00:00:00!!
        let spend_date = 1701907200; // Dec 07 2023 00:00:00
        let expiration_date = 1702166400; // Dec 10 2023 00:00:00
        let t_type = 1;
        let user_keypair = generate_keypair_user();

        // generate authorities keys
        let authorities_keypairs = ttp_keygen(2, 3).unwrap();
        let indices: [u64; 3] = [1, 2, 3];
        let secret_keys_authorities: Vec<&SecretKeyAuth> = authorities_keypairs
            .iter()
            .map(|keypair| keypair.secret_key())
            .collect();
        let verification_keys_auth: Vec<VerificationKeyAuth> = authorities_keypairs
            .iter()
            .map(|keypair| keypair.verification_key())
            .collect();

        let verification_key =
            aggregate_verification_keys(&verification_keys_auth, Some(&[1, 2, 3]))?;

        // generate valid dates signatures
        let dates_signatures = generate_expiration_date_signatures(
            expiration_date,
            &secret_keys_authorities,
            &verification_keys_auth,
            &verification_key,
            &indices,
        )?;

        // generate coin indices signatures
        let coin_indices_signatures = generate_coin_indices_signatures(
            &params,
            &secret_keys_authorities,
            &verification_keys_auth,
            &verification_key,
            &indices,
        )?;

        // request a wallet
        let (req, req_info) =
            withdrawal_request(user_keypair.secret_key(), expiration_date, t_type).unwrap();
        let req_bytes = req.to_bytes();
        let req2 = WithdrawalRequest::try_from(req_bytes.as_slice()).unwrap();
        assert_eq!(req, req2);

        // issue partial wallets
        let mut wallet_blinded_signatures = Vec::new();
        for auth_keypair in authorities_keypairs {
            let blind_signature = issue(
                auth_keypair.secret_key(),
                user_keypair.public_key(),
                &req,
                expiration_date,
                t_type,
            );
            wallet_blinded_signatures.push(blind_signature.unwrap());
        }

        let unblinded_wallet_shares: Vec<PartialWallet> = izip!(
            wallet_blinded_signatures.iter(),
            verification_keys_auth.iter()
        )
        .enumerate()
        .map(|(idx, (w, vk))| {
            issue_verify(vk, user_keypair.secret_key(), w, &req_info, idx as u64 + 1).unwrap()
        })
        .collect();

        let partial_wallet = unblinded_wallet_shares.first().unwrap().clone();
        let partial_wallet_bytes = partial_wallet.to_bytes();
        let partial_wallet2 = PartialWallet::try_from(&partial_wallet_bytes[..]).unwrap();
        assert_eq!(partial_wallet, partial_wallet2);

        // Aggregate partial wallets
        let mut aggr_wallet = aggregate_wallets(
            &verification_key,
            user_keypair.secret_key(),
            &unblinded_wallet_shares,
            &req_info,
        )?;

        let wallet_bytes = aggr_wallet.to_bytes();
        let wallet = Wallet::from_bytes(&wallet_bytes).unwrap();
        assert_eq!(aggr_wallet, wallet);

        // Let's try to spend some coins
        let pay_info = PayInfo {
            pay_info_bytes: [6u8; 72],
        };
        let spend_vv = 1;

        let payment = aggr_wallet.spend(
            &params,
            &verification_key,
            user_keypair.secret_key(),
            &pay_info,
            spend_vv,
            &dates_signatures,
            &coin_indices_signatures,
            spend_date,
        )?;

        assert!(payment
            .spend_verify(&verification_key, &pay_info, spend_date)
            .is_ok());

        let payment_bytes = payment.to_bytes();
        let payment2 = Payment::try_from(&payment_bytes[..]).unwrap();
        assert_eq!(payment, payment2);

        Ok(())
    }
}