leo_lang/cli/commands/
account.rs

1// Copyright (C) 2019-2025 Provable Inc.
2// This file is part of the Leo library.
3
4// The Leo library is free software: you can redistribute it and/or modify
5// it under the terms of the GNU General Public License as published by
6// the Free Software Foundation, either version 3 of the License, or
7// (at your option) any later version.
8
9// The Leo library is distributed in the hope that it will be useful,
10// but WITHOUT ANY WARRANTY; without even the implied warranty of
11// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12// GNU General Public License for more details.
13
14// You should have received a copy of the GNU General Public License
15// along with the Leo library. If not, see <https://www.gnu.org/licenses/>.
16
17use super::*;
18use leo_ast::NetworkName;
19use leo_errors::UtilError;
20
21#[cfg(not(feature = "only_testnet"))]
22use snarkvm::prelude::{CanaryV0, MainnetV0};
23use snarkvm::{
24    console::program::{Signature, ToFields, Value},
25    prelude::{Address, Network, PrivateKey, TestnetV0, ViewKey},
26};
27
28use crossterm::ExecutableCommand;
29use itertools::Itertools;
30use rand::SeedableRng;
31use rand_chacha::ChaChaRng;
32use std::{
33    io::{self, Read, Write},
34    path::PathBuf,
35    str::FromStr,
36};
37
38/// Commands to manage Aleo accounts.
39#[derive(Parser, Debug)]
40pub enum Account {
41    /// Generates a new Aleo account
42    New {
43        /// Seed the RNG with a numeric value.
44        #[clap(short = 's', long)]
45        seed: Option<u64>,
46        /// Write the private key to the .env file.
47        #[clap(short = 'w', long)]
48        write: bool,
49        /// Print sensitive information (such as private key) discreetly to an alternate screen
50        #[clap(long)]
51        discreet: bool,
52        #[clap(short = 'n', long, help = "Name of the network to use", default_value = "testnet")]
53        network: NetworkName,
54        #[clap(
55            short = 'e',
56            long,
57            help = "Endpoint to retrieve network state from.",
58            default_value = "https://api.explorer.provable.com/v1"
59        )]
60        endpoint: String,
61    },
62    /// Derive an Aleo account from a private key.
63    Import {
64        /// Private key plaintext
65        private_key: Option<String>,
66        /// Write the private key to the .env file.
67        #[clap(short = 'w', long)]
68        write: bool,
69        /// Print sensitive information (such as private key) discreetly to an alternate screen
70        #[clap(long)]
71        discreet: bool,
72        #[clap(short = 'n', long, help = "Name of the network to use", default_value = "testnet")]
73        network: NetworkName,
74        #[clap(
75            short = 'e',
76            long,
77            help = "Endpoint to retrieve network state from.",
78            default_value = "https://api.explorer.provable.com/v1"
79        )]
80        endpoint: String,
81    },
82    /// Sign a message using your Aleo private key.
83    Sign {
84        /// Specify the account private key
85        #[clap(long = "private-key")]
86        private_key: Option<String>,
87        /// Specify the path to a file containing the account private key
88        #[clap(long = "private-key-file")]
89        private_key_file: Option<String>,
90        /// Message (Aleo value) to sign
91        #[clap(short = 'm', long)]
92        message: String,
93        /// When enabled, parses the message as bytes instead of Aleo literals
94        #[clap(short = 'r', long)]
95        raw: bool,
96        #[clap(short = 'n', long, help = "Name of the network to use", default_value = "testnet")]
97        network: NetworkName,
98    },
99    /// Verify a message from an Aleo address.
100    Verify {
101        /// Address to use for verification
102        #[clap(short = 'a', long)]
103        address: String,
104        /// Signature to verify
105        #[clap(short = 's', long)]
106        signature: String,
107        /// Message (Aleo value) to verify the signature against
108        #[clap(short = 'm', long)]
109        message: String,
110        /// When enabled, parses the message as bytes instead of Aleo literals
111        #[clap(short = 'r', long)]
112        raw: bool,
113        #[clap(short = 'n', long, help = "Name of the network to use", default_value = "testnet")]
114        network: NetworkName,
115    },
116    /// Decrupt record ciphertext using your Aleo private key or view key.
117    Decrypt {
118        /// Specify the account key
119        #[clap(short = 'k', help = "Private key or view key to use for decryption")]
120        key: Option<String>,
121        /// Specify the path to a file containing the account private key
122        #[clap(short = 'f', help = "Path to a file containing the private key or view key")]
123        key_file: Option<String>,
124        /// The ciphertext to decrypt
125        #[clap(short = 'c', long)]
126        ciphertext: String,
127        #[clap(short = 'n', long, help = "Name of the network to use", default_value = "testnet")]
128        network: NetworkName,
129    },
130}
131
132impl Command for Account {
133    type Input = ();
134    type Output = ();
135
136    fn prelude(&self, _: Context) -> Result<Self::Input>
137    where
138        Self: Sized,
139    {
140        Ok(())
141    }
142
143    fn apply(self, ctx: Context, _: Self::Input) -> Result<Self::Output>
144    where
145        Self: Sized,
146    {
147        match self {
148            Account::New { seed, write, discreet, network, endpoint } => match network {
149                NetworkName::TestnetV0 => {
150                    generate_new_account::<TestnetV0>(network, seed, write, discreet, &ctx, endpoint)
151                }
152                NetworkName::MainnetV0 => {
153                    #[cfg(feature = "only_testnet")]
154                    panic!("Mainnet chosen with only_testnet feature");
155                    #[cfg(not(feature = "only_testnet"))]
156                    generate_new_account::<MainnetV0>(network, seed, write, discreet, &ctx, endpoint)
157                }
158                NetworkName::CanaryV0 => {
159                    #[cfg(feature = "only_testnet")]
160                    panic!("Canary chosen with only_testnet feature");
161                    #[cfg(not(feature = "only_testnet"))]
162                    generate_new_account::<CanaryV0>(network, seed, write, discreet, &ctx, endpoint)
163                }
164            }?,
165            Account::Import { private_key, write, discreet, network, endpoint } => match network {
166                NetworkName::TestnetV0 => {
167                    import_account::<TestnetV0>(network, private_key, write, discreet, &ctx, endpoint)
168                }
169                NetworkName::MainnetV0 => {
170                    #[cfg(feature = "only_testnet")]
171                    panic!("Mainnet chosen with only_testnet feature");
172                    #[cfg(not(feature = "only_testnet"))]
173                    import_account::<MainnetV0>(network, private_key, write, discreet, &ctx, endpoint)
174                }
175                NetworkName::CanaryV0 => {
176                    #[cfg(feature = "only_testnet")]
177                    panic!("Canary chosen with only_testnet feature");
178                    #[cfg(not(feature = "only_testnet"))]
179                    import_account::<CanaryV0>(network, private_key, write, discreet, &ctx, endpoint)
180                }
181            }?,
182            Self::Sign { message, raw, private_key, private_key_file, network } => {
183                let result = match network {
184                    NetworkName::TestnetV0 => sign_message::<TestnetV0>(message, raw, private_key, private_key_file),
185                    NetworkName::MainnetV0 => {
186                        #[cfg(feature = "only_testnet")]
187                        panic!("Mainnet chosen with only_testnet feature");
188                        #[cfg(not(feature = "only_testnet"))]
189                        sign_message::<MainnetV0>(message, raw, private_key, private_key_file)
190                    }
191                    NetworkName::CanaryV0 => {
192                        #[cfg(feature = "only_testnet")]
193                        panic!("Canary chosen with only_testnet feature");
194                        #[cfg(not(feature = "only_testnet"))]
195                        sign_message::<CanaryV0>(message, raw, private_key, private_key_file)
196                    }
197                }?;
198                println!("{result}")
199            }
200            Self::Verify { address, signature, message, raw, network } => {
201                let result = match network {
202                    NetworkName::TestnetV0 => verify_message::<TestnetV0>(address, signature, message, raw),
203                    NetworkName::MainnetV0 => {
204                        #[cfg(feature = "only_testnet")]
205                        panic!("Mainnet chosen with only_testnet feature");
206                        #[cfg(not(feature = "only_testnet"))]
207                        verify_message::<MainnetV0>(address, signature, message, raw)
208                    }
209                    NetworkName::CanaryV0 => {
210                        #[cfg(feature = "only_testnet")]
211                        panic!("Canary chosen with only_testnet feature");
212                        #[cfg(not(feature = "only_testnet"))]
213                        verify_message::<CanaryV0>(address, signature, message, raw)
214                    }
215                }?;
216                println!("{result}")
217            }
218            Self::Decrypt { key, key_file, ciphertext, network } => {
219                let result = match network {
220                    NetworkName::TestnetV0 => decrypt_ciphertext::<TestnetV0>(key, key_file, &ciphertext),
221                    NetworkName::MainnetV0 => {
222                        #[cfg(feature = "only_testnet")]
223                        panic!("Mainnet chosen with only_testnet feature");
224                        #[cfg(not(feature = "only_testnet"))]
225                        decrypt_ciphertext::<MainnetV0>(key, key_file, &ciphertext)
226                    }
227                    NetworkName::CanaryV0 => {
228                        #[cfg(feature = "only_testnet")]
229                        panic!("Canary chosen with only_testnet feature");
230                        #[cfg(not(feature = "only_testnet"))]
231                        decrypt_ciphertext::<CanaryV0>(key, key_file, &ciphertext)
232                    }
233                }?;
234                println!("{result}")
235            }
236        }
237        Ok(())
238    }
239}
240
241// Helper functions
242
243// Generate a new account.
244fn generate_new_account<N: Network>(
245    network: NetworkName,
246    seed: Option<u64>,
247    write: bool,
248    discreet: bool,
249    ctx: &Context,
250    endpoint: String,
251) -> Result<()> {
252    // Sample a new Aleo account.
253    let private_key = match seed {
254        // Recover the field element deterministically.
255        Some(seed) => PrivateKey::<N>::new(&mut ChaChaRng::seed_from_u64(seed)),
256        // Sample a random field element.
257        None => PrivateKey::new(&mut ChaChaRng::from_entropy()),
258    }
259    .map_err(CliError::failed_to_parse_seed)?;
260
261    // Derive the view key and address and print to stdout.
262    print_keys(private_key, discreet)?;
263
264    // Save key data to .env file.
265    if write {
266        write_to_env_file(network, private_key, ctx, endpoint)?;
267    }
268    Ok(())
269}
270
271// Import an account.
272fn import_account<N: Network>(
273    network: NetworkName,
274    private_key: Option<String>,
275    write: bool,
276    discreet: bool,
277    ctx: &Context,
278    endpoint: String,
279) -> Result<()> {
280    let priv_key = match discreet {
281        true => {
282            let private_key_input = rpassword::prompt_password("Please enter your private key: ").unwrap();
283            FromStr::from_str(&private_key_input).map_err(CliError::failed_to_parse_private_key)?
284        }
285        false => match private_key {
286            Some(private_key) => FromStr::from_str(&private_key).map_err(CliError::failed_to_parse_private_key)?,
287            None => {
288                return Err(CliError::failed_to_execute_account(
289                    "PRIVATE_KEY shouldn't be empty when --discreet is false",
290                )
291                .into());
292            }
293        },
294    };
295
296    // Derive the view key and address and print to stdout.
297    print_keys::<N>(priv_key, discreet)?;
298
299    // Save key data to .env file.
300    if write {
301        write_to_env_file::<N>(network, priv_key, ctx, endpoint)?;
302    }
303
304    Ok(())
305}
306
307// Print keys as a formatted string without log level.
308fn print_keys<N: Network>(private_key: PrivateKey<N>, discreet: bool) -> Result<()> {
309    let view_key = ViewKey::try_from(&private_key)?;
310    let address = Address::<N>::try_from(&view_key)?;
311
312    if !discreet {
313        println!(
314            "\n {:>12}  {private_key}\n {:>12}  {view_key}\n {:>12}  {address}\n",
315            "Private Key".cyan().bold(),
316            "View Key".cyan().bold(),
317            "Address".cyan().bold(),
318        );
319        return Ok(());
320    }
321    display_string_discreetly(
322        &private_key.to_string(),
323        "### Do not share or lose this private key! Press any key to complete. ###",
324    )?;
325    println!("\n {:>12}  {view_key}\n {:>12}  {address}\n", "View Key".cyan().bold(), "Address".cyan().bold(),);
326
327    Ok(())
328}
329
330// Sign a message with an Aleo private key
331pub(crate) fn sign_message<N: Network>(
332    message: String,
333    raw: bool,
334    private_key: Option<String>,
335    private_key_file: Option<String>,
336) -> Result<String> {
337    // Get the private key string.
338    let private_key_string = get_key_string(private_key, private_key_file, &["PRIVATE_KEY"])?;
339
340    // Parse the private key.
341    let private_key_string = private_key_string.trim();
342    let private_key = PrivateKey::<N>::from_str(private_key_string)
343        .map_err(|_| CliError::cli_invalid_input("Failed to parse a valid private key"))?;
344
345    // Sample a random field element.
346    let mut rng = ChaChaRng::from_entropy();
347
348    // Sign the message
349    let signature = if raw {
350        private_key.sign_bytes(message.as_bytes(), &mut rng)
351    } else {
352        let fields = Value::<N>::from_str(&message)?
353            .to_fields()
354            .map_err(|_| CliError::cli_invalid_input("Failed to parse a valid Aleo value"))?;
355        private_key.sign(&fields, &mut rng)
356    }
357    .map_err(|_| CliError::cli_runtime_error("Failed to sign the message"))?
358    .to_string();
359    // Return the signature as a string
360    Ok(signature)
361}
362
363// Verify a signature with an Aleo address
364pub(crate) fn verify_message<N: Network>(
365    address: String,
366    signature: String,
367    message: String,
368    raw: bool,
369) -> Result<String> {
370    // Parse the address.
371    let address = Address::<N>::from_str(&address)?;
372
373    let signature = Signature::<N>::from_str(&signature)
374        .map_err(|e| CliError::cli_invalid_input(format!("Failed to parse a valid signature: {e}")))?;
375
376    // Verify the signature
377    let verified = if raw {
378        signature.verify_bytes(&address, message.as_bytes())
379    } else {
380        let fields = Value::<N>::from_str(&message)?
381            .to_fields()
382            .map_err(|_| CliError::cli_invalid_input("Failed to parse a valid Aleo value"))?;
383        signature.verify(&address, &fields)
384    };
385
386    // Return the verification result
387    match verified {
388        true => Ok("✅ The signature is valid".to_string()),
389        false => Err(CliError::cli_runtime_error("❌ The signature is invalid"))?,
390    }
391}
392
393// Decrypt a record ciphertext using a private key or view key.
394pub(crate) fn decrypt_ciphertext<N: Network>(
395    key: Option<String>,
396    key_file: Option<String>,
397    ciphertext: &str,
398) -> Result<String> {
399    // Get the key string.
400    let key_string = get_key_string(key, key_file, &["PRIVATE_KEY", "VIEW_KEY"])?;
401
402    // Parse the key.
403    let key_string = key_string.trim();
404    let view_key = if key_string.starts_with("APrivateKey1") {
405        // If the key starts with "APrivateKey1", treat it as a private key.
406        let private_key = PrivateKey::<N>::from_str(key_string)
407            .map_err(|_| CliError::cli_invalid_input("Failed to parse a valid private key"))?;
408        // Convert the private key to a view key.
409        ViewKey::<N>::try_from(&private_key)
410            .map_err(|_| CliError::cli_invalid_input("Failed to convert private key to view key"))?
411    } else if key_string.starts_with("AViewKey1") {
412        // If the key starts with "AViewKey1", treat it as a view key.
413        ViewKey::<N>::from_str(key_string)
414            .map_err(|_| CliError::cli_invalid_input("Failed to parse a valid view key"))?
415    } else {
416        // If the key is neither, return an error.
417        Err(CliError::cli_invalid_input("Invalid key format. Expected a private or view key."))?
418    };
419
420    // Parse the ciphertext as record ciphertext.
421    let record_ciphertext = Record::<N, Ciphertext<N>>::from_str(ciphertext)
422        .map_err(|_| CliError::cli_invalid_input("Failed to parse a valid record ciphertext"))?;
423
424    // Decrypt the record.
425    let decrypted_value = record_ciphertext
426        .decrypt(&view_key)
427        .map_err(|_| CliError::cli_runtime_error("Failed to decrypt the record ciphertext"))?;
428
429    // Return the decrypted value as a string.
430    Ok(decrypted_value.to_string())
431}
432
433// A helper function to get the key string from the environment or file.
434fn get_key_string(key: Option<String>, key_file: Option<String>, env_vars: &[&'static str]) -> Result<String> {
435    match (key, key_file) {
436        (Some(key), None) => Ok(key),
437        (None, Some(key_file)) => {
438            let path =
439                key_file.parse::<PathBuf>().map_err(|e| CliError::cli_invalid_input(format!("Invalid path - {e}")))?;
440            std::fs::read_to_string(path).map_err(|e| UtilError::failed_to_read_file(e).into())
441        }
442        (None, None) => {
443            // Attempt to pull any of the environment variables
444            env_vars.iter().find_map(|&var| std::env::var(var).ok()).ok_or_else(|| {
445                CliError::cli_invalid_input(format!(
446                    "Missing the '--key', '--key-file', or the following environment variables: '{}'",
447                    env_vars.iter().format(",")
448                ))
449                .into()
450            })
451        }
452        (Some(_), Some(_)) => {
453            Err(CliError::cli_invalid_input("Cannot specify both the '--key' and '--key-file' flags").into())
454        }
455    }
456}
457
458// Write the network and private key to an .env file in project directory.
459fn write_to_env_file<N: Network>(
460    network: NetworkName,
461    private_key: PrivateKey<N>,
462    ctx: &Context,
463    endpoint: String,
464) -> Result<()> {
465    let program_dir = ctx.dir()?;
466    let env_path = program_dir.join(".env");
467    std::fs::write(env_path, format!("NETWORK={network}\nPRIVATE_KEY={private_key}\nENDPOINT={endpoint}\n"))
468        .map_err(PackageError::io_error_env_file)?;
469    tracing::info!("✅ Private Key written to {}", program_dir.join(".env").display());
470    Ok(())
471}
472
473/// Print the string to an alternate screen, so that the string won't been printed to the terminal.
474fn display_string_discreetly(discreet_string: &str, continue_message: &str) -> Result<()> {
475    use crossterm::{
476        style::Print,
477        terminal::{EnterAlternateScreen, LeaveAlternateScreen},
478    };
479    let mut stdout = io::stdout();
480    stdout.execute(EnterAlternateScreen).unwrap();
481    // print msg on the alternate screen
482    stdout.execute(Print(format!("{discreet_string}\n{continue_message}"))).unwrap();
483    stdout.flush().unwrap();
484    wait_for_keypress();
485    stdout.execute(LeaveAlternateScreen).unwrap();
486    Ok(())
487}
488
489fn wait_for_keypress() {
490    let mut single_key = [0u8];
491    std::io::stdin().read_exact(&mut single_key).unwrap();
492}
493
494#[cfg(test)]
495mod tests {
496    use super::{decrypt_ciphertext, sign_message, verify_message};
497    use snarkvm::{
498        prelude::{
499            Address,
500            Identifier,
501            Network,
502            Plaintext,
503            PrivateKey,
504            Process,
505            ProgramID,
506            Record,
507            Scalar,
508            TestRng,
509            U8,
510            Uniform,
511            ViewKey,
512        },
513        synthesizer::program::StackTrait,
514    };
515    use std::str::FromStr;
516
517    type CurrentNetwork = snarkvm::prelude::MainnetV0;
518
519    #[test]
520    fn test_signature_raw() {
521        let key = "APrivateKey1zkp61PAYmrYEKLtRWeWhUoDpFnGLNuHrCciSqN49T86dw3p".to_string();
522        let message = "Hello, world!".to_string();
523        assert!(sign_message::<CurrentNetwork>(message, true, Some(key), None).is_ok());
524    }
525
526    #[test]
527    fn test_signature() {
528        let key = "APrivateKey1zkp61PAYmrYEKLtRWeWhUoDpFnGLNuHrCciSqN49T86dw3p".to_string();
529        let message = "5field".to_string();
530        assert!(sign_message::<CurrentNetwork>(message, false, Some(key), None).is_ok());
531    }
532
533    #[test]
534    fn test_signature_fail() {
535        let key = "APrivateKey1zkp61PAYmrYEKLtRWeWhUoDpFnGLNuHrCciSqN49T86dw3p".to_string();
536        let message = "not a literal value".to_string();
537        assert!(sign_message::<CurrentNetwork>(message, false, Some(key), None).is_err());
538    }
539
540    #[test]
541    fn test_verify_raw() {
542        // test signature of "Hello, world!"
543        let address = "aleo1zecnqchckrzw7dlsyf65g6z5le2rmys403ecwmcafrag0e030yxqrnlg8j".to_string();
544        let signature = "sign1nnvrjlksrkxdpwsrw8kztjukzhmuhe5zf3srk38h7g32u4kqtqpxn3j5a6k8zrqcfx580a96956nsjvluzt64cqf54pdka9mgksfqp8esm5elrqqunzqzmac7kzutl6zk7mqht3c0m9kg4hklv7h2js0qmxavwnpuwyl4lzldl6prs4qeqy9wxyp8y44nnydg3h8sg6ue99qkwsnaqq".to_string();
545        let message = "Hello, world!".to_string();
546        assert!(verify_message::<CurrentNetwork>(address.clone(), signature, message, true).is_ok());
547
548        // test signature of "Hello, world!" against the message "Different Message"
549        let signature = "sign1nnvrjlksrkxdpwsrw8kztjukzhmuhe5zf3srk38h7g32u4kqtqpxn3j5a6k8zrqcfx580a96956nsjvluzt64cqf54pdka9mgksfqp8esm5elrqqunzqzmac7kzutl6zk7mqht3c0m9kg4hklv7h2js0qmxavwnpuwyl4lzldl6prs4qeqy9wxyp8y44nnydg3h8sg6ue99qkwsnaqq".to_string();
550        let message = "Different Message".to_string();
551        assert!(verify_message::<CurrentNetwork>(address.clone(), signature, message, true).is_err());
552
553        // test signature of "Hello, world!" against the wrong address
554        let signature = "sign1nnvrjlksrkxdpwsrw8kztjukzhmuhe5zf3srk38h7g32u4kqtqpxn3j5a6k8zrqcfx580a96956nsjvluzt64cqf54pdka9mgksfqp8esm5elrqqunzqzmac7kzutl6zk7mqht3c0m9kg4hklv7h2js0qmxavwnpuwyl4lzldl6prs4qeqy9wxyp8y44nnydg3h8sg6ue99qkwsnaqq".to_string();
555        let message = "Hello, world!".to_string();
556        let wrong_address = "aleo1uxl69laseuv3876ksh8k0nd7tvpgjt6ccrgccedpjk9qwyfensxst9ftg5".to_string();
557        assert!(verify_message::<CurrentNetwork>(wrong_address, signature, message, true).is_err());
558
559        // test a valid signature of "Different Message"
560        let signature = "sign1424ztyt9hcm77nq450gvdszrvtg9kvhc4qadg4nzy9y0ah7wdqq7t36cxal42p9jj8e8pjpmc06lfev9nvffcpqv0cxwyr0a2j2tjqlesm5elrqqunzqzmac7kzutl6zk7mqht3c0m9kg4hklv7h2js0qmxavwnpuwyl4lzldl6prs4qeqy9wxyp8y44nnydg3h8sg6ue99qk3yrr50".to_string();
561        let message = "Different Message".to_string();
562        assert!(verify_message::<CurrentNetwork>(address, signature, message, true).is_ok());
563    }
564
565    #[test]
566    fn test_verify() {
567        // test signature of 5u8
568        let address = "aleo1zecnqchckrzw7dlsyf65g6z5le2rmys403ecwmcafrag0e030yxqrnlg8j".to_string();
569        let signature = "sign1j7swjfnyujt2vme3ulu88wdyh2ddj85arh64qh6c6khvrx8wvsp8z9wtzde0sahqj2qwz8rgzt803c0ceega53l4hks2mf5sfsv36qhesm5elrqqunzqzmac7kzutl6zk7mqht3c0m9kg4hklv7h2js0qmxavwnpuwyl4lzldl6prs4qeqy9wxyp8y44nnydg3h8sg6ue99qkdetews".to_string();
570        let message = "5field".to_string();
571        assert!(verify_message::<CurrentNetwork>(address.clone(), signature, message, false).is_ok());
572
573        // test signature of 5u8 against the message 10u8
574        let signature = "sign1j7swjfnyujt2vme3ulu88wdyh2ddj85arh64qh6c6khvrx8wvsp8z9wtzde0sahqj2qwz8rgzt803c0ceega53l4hks2mf5sfsv36qhesm5elrqqunzqzmac7kzutl6zk7mqht3c0m9kg4hklv7h2js0qmxavwnpuwyl4lzldl6prs4qeqy9wxyp8y44nnydg3h8sg6ue99qkdetews".to_string();
575        let message = "10field".to_string();
576        assert!(verify_message::<CurrentNetwork>(address.clone(), signature, message, false).is_err());
577
578        // test signature of 5u8 against the wrong address
579        let signature = "sign1j7swjfnyujt2vme3ulu88wdyh2ddj85arh64qh6c6khvrx8wvsp8z9wtzde0sahqj2qwz8rgzt803c0ceega53l4hks2mf5sfsv36qhesm5elrqqunzqzmac7kzutl6zk7mqht3c0m9kg4hklv7h2js0qmxavwnpuwyl4lzldl6prs4qeqy9wxyp8y44nnydg3h8sg6ue99qkdetews".to_string();
580        let message = "5field".to_string();
581        let wrong_address = "aleo1uxl69laseuv3876ksh8k0nd7tvpgjt6ccrgccedpjk9qwyfensxst9ftg5".to_string();
582        assert!(verify_message::<CurrentNetwork>(wrong_address, signature, message, false).is_err());
583
584        // test a valid signature of 10u8
585        let signature = "sign1t9v2t5tljk8pr5t6vkcqgkus0a3v69vryxmfrtwrwg0xtj7yv5qj2nz59e5zcyl50w23lhntxvt6vzeqfyu6dt56698zvfj2l6lz6q0esm5elrqqunzqzmac7kzutl6zk7mqht3c0m9kg4hklv7h2js0qmxavwnpuwyl4lzldl6prs4qeqy9wxyp8y44nnydg3h8sg6ue99qk8rh9kt".to_string();
586        let message = "10field".to_string();
587        assert!(verify_message::<CurrentNetwork>(address, signature, message, false).is_ok());
588    }
589
590    #[test]
591    fn test_decrypt() -> anyhow::Result<()> {
592        // Initialize an RNG.
593        let mut rng = &mut TestRng::default();
594
595        // Test decryption with a private key
596        let private_key =
597            PrivateKey::<CurrentNetwork>::from_str("APrivateKey1zkp8CZNn3yeCseEtxuVPbDCwSyhGW6yZKUYKfgXmcpoGPWH")?;
598        let private_key_string = private_key.to_string();
599        let view_key = ViewKey::<CurrentNetwork>::try_from(&private_key)?;
600        let view_key_string = view_key.to_string();
601        let address = Address::<CurrentNetwork>::try_from(&view_key)?;
602
603        // Create a random record.
604        let process = Process::<CurrentNetwork>::load()?;
605        let stack = process.get_stack(ProgramID::from_str("credits.aleo")?)?;
606        let randomizer = Scalar::<CurrentNetwork>::rand(rng);
607        let nonce = CurrentNetwork::g_scalar_multiply(&randomizer);
608        let record = stack.sample_record(&address, &Identifier::from_str("credits").unwrap(), nonce, &mut rng)?;
609        let record = Record::<CurrentNetwork, Plaintext<CurrentNetwork>>::from_plaintext(
610            record.owner().clone(),
611            record.data().clone(),
612            nonce,
613            U8::new(u8::rand(rng) % 2),
614        )?;
615        let record_string = record.to_string();
616        let ciphertext = record.encrypt(randomizer)?;
617        let ciphertext_string = ciphertext.to_string();
618
619        // Test decryption with the private key
620        let candidate = decrypt_ciphertext::<CurrentNetwork>(Some(private_key_string), None, &ciphertext_string)?;
621        assert_eq!(candidate, record_string);
622
623        // Test decryption with a view key
624        let candidate = decrypt_ciphertext::<CurrentNetwork>(Some(view_key_string), None, &ciphertext_string)?;
625        assert_eq!(candidate, record_string);
626
627        Ok(())
628    }
629}
leo_lang/cli/commands/account.rs

leo_lang/cli/commands/
account.rs
