feat(nip-06): mnemonic seed phrase

* feat(cli): read secret key and mnemonic from an environment variable
* feat(cli): print secret key

Author: gislik

Cargo.lock

@@ -7,8 +7,10 @@ edition = "2021"
 
 [dependencies]
 aes = "0.8.2"
+anyhow = "1.0.69"
 base64 = "0.21.0"
 bech32 = "0.9.1"
+bip32 = { version = "0.4.0", featues = ["secp256k1-ffi"]}
 cbc = { version = "0.1.2", features = ["block-padding", "alloc"]}
 clap = { version = "4.1.4", features = ["derive"] }
 hex = "0.4.3"

Cargo.toml

@@ -15,12 +15,14 @@ Library:
 - [x] Generate and sign an event
 - [x] Construct messages requests
 - [x] Parse message responses
-- [ ] Direct message support 
+- [x] Direct message support 
+- [x] Seed phrases
 
 CLI: 
 
 - [x] Read an event as json from stdin and verify
 - [x] Generate an event from cli arguments and write to stdout as json.
 - [x] Generate message requests
-- [ ] Generate a new key and print to stdout
+- [x] Generate a new key and print to stdout
 - [ ] Read the private key from an environment variable
+- [ ] Derive the private key from a mnemonic, read from an environment variable

README.md

@@ -1,10 +1,119 @@
-use std::io::{stdout, Error, ErrorKind, Read, Result, Write};
+use std::io::{stdin, stdout, Error, ErrorKind, Read, Write};
 
 use crate::event::{Event, Kind};
 use crate::key::Pair;
 use crate::message::MessageRequest;
 use crate::request::Request;
 use crate::Hex;
+use anyhow::Result;
+use clap::{Parser, Subcommand};
+
+#[derive(Parser)]
+#[command(author, version, about, long_about)]
+pub struct Args {
+    #[command(subcommand)]
+    command: Command,
+}
+
+#[derive(Subcommand)]
+enum Command {
+    /// Verify and generate events
+    Event {
+        #[command(subcommand)]
+        subcommand: EventCommand,
+    },
+    /// Generate requests
+    Request {
+        #[arg(short, long)]
+        ids: Vec<Hex>,
+        #[arg(short, long)]
+        authors: Vec<Hex>,
+        #[arg(short, long)]
+        kinds: Vec<u32>,
+        #[arg(short, long)]
+        e: Vec<Hex>,
+        #[arg(short, long)]
+        p: Vec<Hex>,
+        #[arg(short, long)]
+        since: Option<u32>,
+        #[arg(short, long)]
+        until: Option<u32>,
+        #[arg(short, long)]
+        limit: Option<u16>,
+    },
+    /// Generate message requests
+    MessageRequest {
+        #[command(subcommand)]
+        subcommand: MessageRequestCommand,
+    },
+    /// Print key
+    Key,
+}
+
+#[derive(Subcommand)]
+pub enum EventCommand {
+    /// Verifies an event on stdin
+    Verify,
+    /// Output a new event to stdout
+    Generate {
+        #[arg(short, long)]
+        kind: Kind,
+        content: String,
+    },
+    /// Output a new set metadata event to stdout
+    SetMetadata {
+        name: String,
+        about: String,
+        picture: String,
+    },
+    /// Output a new text note to stdout
+    TextNote { content: String },
+    /// Output a new recommend relay to stdout
+    RecommendRelay { relay: String },
+}
+
+// #[derive(Subcommand)]
+// pub enum RequestCommand {}
+
+#[derive(Subcommand)]
+pub enum MessageRequestCommand {
+    Event,
+    Request { id: String },
+}
+
+pub fn handle_args(args: Args, pair: &Pair) -> Result<()> {
+    match args.command {
+        Command::Event { subcommand } => match subcommand {
+            EventCommand::Verify => verify_event(stdin())?,
+            EventCommand::Generate { kind, content } => generate_event(kind, &content)?,
+            EventCommand::SetMetadata {
+                name,
+                about,
+                picture,
+            } => set_metadata_event(&name, &about, &picture)?,
+            EventCommand::TextNote { content } => text_note_event(&content)?,
+            EventCommand::RecommendRelay { relay } => recommend_relay_event(&relay)?,
+        },
+        Command::Request {
+            ids,
+            authors,
+            kinds,
+            e,
+            p,
+            since,
+            until,
+            limit,
+        } => write_request(stdout(), ids, authors, kinds, e, p, since, until, limit)?,
+        Command::MessageRequest { subcommand } => match subcommand {
+            MessageRequestCommand::Event => event_message_request(stdin(), stdout())?,
+            MessageRequestCommand::Request { id } => {
+                request_message_request(stdin(), stdout(), id)?
+            }
+        },
+        Command::Key => print_key(&mut stdout(), pair)?,
+    };
+    Ok(())
+}
 
 pub fn io_error(message: &str) -> Error {
     Error::new(ErrorKind::Other, message)
@@ -99,3 +208,8 @@ pub fn request_message_request<R: Read, W: Write>(reader: R, writer: W, id: Stri
     serde_json::to_writer(writer, &message)?;
     Ok(())
 }
+
+pub fn print_key<W: Write>(writer: &mut W, pair: &Pair) -> Result<()> {
+    writer.write_all(pair.secret_key().unwrap().display_secret_as_nsec().as_ref())?;
+    Ok(())
+}

src/cli.rs

@@ -0,0 +1,34 @@
+use std::env::{self, VarError};
+
+use anyhow::{Error, Result};
+
+pub fn var(key: &str) -> Var<String> {
+    Var(env::var(key).map_err(Error::from))
+}
+
+pub struct Var<T>(Result<T>);
+
+impl<T> Var<T> {
+    pub fn new(var: T) -> Self {
+        Var(Ok(var))
+    }
+    pub fn or_missing(self, value: Self) -> Self {
+        let result = self.0.or_else(|err: Error| match err.downcast_ref() {
+            Some(VarError::NotPresent) => value.0,
+            _ => Err(err),
+        });
+        Self(result)
+    }
+
+    pub fn and_then<F, U>(self, f: F) -> Var<U>
+    where
+        F: FnOnce(T) -> Result<U>,
+    {
+        let result = self.0.and_then(f);
+        Var(result)
+    }
+
+    pub fn to_result(self) -> Result<T> {
+        self.0
+    }
+}

src/env.rs

@@ -156,7 +156,8 @@ pub struct Contact {
 
 type Result<T> = std::result::Result<T, Error>;
 
-#[derive(Debug)]
+#[derive(Debug, thiserror::Error)]
+#[error("event error")]
 pub enum Error {
     HashMismatch,
     Signature(signature::Error),

src/event.rs

@@ -4,6 +4,8 @@ use std::str::FromStr;
 use crate::bech32;
 use crate::bech32::nsec::SECRET_PREFIX;
 use crate::encryption;
+use crate::mnemonic;
+use crate::mnemonic::Mnemonic;
 use crate::signature::Signature;
 use secp256k1 as ec;
 use secp256k1::schnorr;
@@ -23,6 +25,15 @@ pub struct Pair {
 }
 
 impl Pair {
+    pub fn new<S>(secret_key: S) -> Result<Self>
+    where
+        S: AsRef<str>,
+    {
+        let sk = SecretKey::from_str(secret_key.as_ref())?;
+        let pair = Self::from(&sk);
+        Ok(pair)
+    }
+
     /// Generates a new SECP256k1 key pair.
     pub fn generate() -> Self {
         let (sk, pk) = ec::generate_keypair(&mut ec::rand::thread_rng());
@@ -35,6 +46,16 @@ impl Pair {
         }
     }
 
+    /// Creates a new pair from a mnemonic.
+    /// Defined in [NIP-01](https://github.com/nostr-protocol/nips/blob/master/06.md).
+    pub fn from_mnemonic<S>(s: S) -> Result<Self>
+    where
+        S: AsRef<str>,
+    {
+        let mnemonic = Mnemonic::new(s.as_ref())?;
+        Pair::try_from(&mnemonic)
+    }
+
     pub fn new_shared_secret(ours: &SecretKey, theirs: &PublicKey) -> Self {
         let pk = theirs.0.public_key(ec::Parity::Even); // parity is not important
         let sk = ours.0;
@@ -103,6 +124,17 @@ impl From<&PublicKey> for Pair {
     }
 }
 
+impl TryFrom<&Mnemonic> for Pair {
+    type Error = Error;
+
+    fn try_from(mnemonic: &Mnemonic) -> result::Result<Self, Self::Error> {
+        let bytes = mnemonic.to_bytes();
+        let sk = SecretKey::try_from(&bytes[..])?;
+        let pair = Pair::from(&sk);
+        Ok(pair)
+    }
+}
+
 /// Secret key
 #[derive(Clone, Copy)]
 pub struct SecretKey(ec::SecretKey);
@@ -205,11 +237,14 @@ pub enum Error {
     Signature(String),
     #[error("encryption")]
     Encryption(#[from] encryption::Error),
+    #[error("mnemonic")]
+    Mnemonic(#[from] mnemonic::Error),
 }
 
 #[cfg(test)]
 pub mod tests {
     use super::*;
+    use crate::bech32::ToBech32;
 
     fn get_secret_key() -> SecretKey {
         SecretKey::from_str("0f1429676edf1ff8e5ca8202c8741cb695fc3ce24ec3adc0fcf234116f08f849")
@@ -275,4 +310,14 @@ pub mod tests {
         assert_eq!(got, want);
         Ok(())
     }
+
+    #[test]
+    fn from_mnemonic_works() -> Result<()> {
+        let s = crate::mnemonic::tests::get_mnemonic_str();
+        let pair = Pair::from_mnemonic(s)?;
+        let got = pair.public_key().to_bech32();
+        let want = "npub1gw5zyqa9yj2rrq5u683y9sfdpv49hmgfkw37hupgvf5vrtdmr60sspjdzz";
+        assert_eq!(got, want);
+        Ok(())
+    }
 }

src/key.rs

@@ -1,9 +1,11 @@
 pub mod bech32;
 pub mod cli;
 pub mod encryption;
+pub mod env;
 pub mod event;
 pub mod key;
 pub mod message;
+pub mod mnemonic;
 pub mod request;
 pub mod signature;
 pub mod time;