Merge pull request #104 from kwsantiago/kyle/fix-issue-70

Author: bennyhodl

ddk-node/src/cli_opts.rs

@@ -76,7 +76,34 @@ pub enum OracleCommand {
         #[arg(help = "The outcomes of the event. Separate by spaces.")]
         outcomes: Vec<String>,
     },
+    #[command(about = "Create a numeric oracle event.")]
+    CreateNumeric {
+        #[arg(help = "The maturity of the event.")]
+        maturity: u32,
+        #[arg(help = "Number of digits for the numeric event.")]
+        nb_digits: u32,
+    },
+    #[command(about = "Sign an oracle announcement.")]
+    Sign {
+        #[arg(
+            long,
+            help = "Specify if the event is enum.",
+            conflicts_with = "numeric"
+        )]
+        r#enum: bool,
+        #[arg(
+            long,
+            help = "Specify if the event is numeric.",
+            conflicts_with = "enum"
+        )]
+        numeric: bool,
+        #[arg(long, help = "The outcome to sign.")]
+        outcome: String,
+        #[arg(long, help = "The event id to sign.")]
+        event_id: String,
+    },
 }
+
 #[derive(Parser, Clone, Debug)]
 pub struct Accept {
     // The contract id string to accept.
@@ -88,3 +115,112 @@ pub struct Connect {
     #[arg(help = "The public key to connect to.")]
     pub pubkey: String,
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_oracle_create_enum_structure() {
+        // Test creating an enum oracle command
+        let cmd = OracleCommand::CreateEnum {
+            maturity: 1234567890,
+            outcomes: vec!["YES".to_string(), "NO".to_string()],
+        };
+
+        match cmd {
+            OracleCommand::CreateEnum { maturity, outcomes } => {
+                assert_eq!(maturity, 1234567890);
+                assert_eq!(outcomes, vec!["YES", "NO"]);
+            }
+            _ => panic!("Wrong variant"),
+        }
+    }
+
+    #[test]
+    fn test_oracle_create_numeric_structure() {
+        // Test creating a numeric oracle command
+        let cmd = OracleCommand::CreateNumeric {
+            maturity: 1234567890,
+            nb_digits: 5,
+        };
+
+        match cmd {
+            OracleCommand::CreateNumeric {
+                maturity,
+                nb_digits,
+            } => {
+                assert_eq!(maturity, 1234567890);
+                assert_eq!(nb_digits, 5);
+            }
+            _ => panic!("Wrong variant"),
+        }
+    }
+
+    #[test]
+    fn test_oracle_sign_enum_structure() {
+        // Test creating a sign command with enum flag
+        let cmd = OracleCommand::Sign {
+            r#enum: true,
+            numeric: false,
+            outcome: "YES".to_string(),
+            event_id: "test123".to_string(),
+        };
+
+        match cmd {
+            OracleCommand::Sign {
+                r#enum,
+                numeric,
+                outcome,
+                event_id,
+            } => {
+                assert!(r#enum);
+                assert!(!numeric);
+                assert_eq!(outcome, "YES");
+                assert_eq!(event_id, "test123");
+            }
+            _ => panic!("Wrong variant"),
+        }
+    }
+
+    #[test]
+    fn test_oracle_sign_numeric_structure() {
+        // Test creating a sign command with numeric flag
+        let cmd = OracleCommand::Sign {
+            r#enum: false,
+            numeric: true,
+            outcome: "42".to_string(),
+            event_id: "test123".to_string(),
+        };
+
+        match cmd {
+            OracleCommand::Sign {
+                r#enum,
+                numeric,
+                outcome,
+                event_id,
+            } => {
+                assert!(!r#enum);
+                assert!(numeric);
+                assert_eq!(outcome, "42");
+                assert_eq!(event_id, "test123");
+            }
+            _ => panic!("Wrong variant"),
+        }
+    }
+
+    #[test]
+    fn test_oracle_announcements_structure() {
+        // Test creating an announcements command
+        let cmd = OracleCommand::Announcements {
+            event_id: "event123".to_string(),
+        };
+
+        match cmd {
+            OracleCommand::Announcements { event_id } => {
+                assert_eq!(event_id, "event123");
+            }
+            _ => panic!("Wrong variant"),
+        }
+    }
+}

ddk-node/src/command.rs

@@ -1,13 +1,13 @@
 use std::sync::Arc;
 
 use crate::cli_opts::{CliCommand, OracleCommand, WalletCommand};
-// use crate::convert::*;
 use crate::ddkrpc::ddk_rpc_client::DdkRpcClient;
 use crate::ddkrpc::{
-    AcceptOfferRequest, ConnectRequest, CreateEnumRequest, GetWalletTransactionsRequest,
-    InfoRequest, ListContractsRequest, ListOffersRequest, ListPeersRequest, ListUtxosRequest,
-    NewAddressRequest, OracleAnnouncementsRequest, SendOfferRequest, SendRequest, SyncRequest,
-    WalletBalanceRequest, WalletSyncRequest,
+    sign_request, AcceptOfferRequest, ConnectRequest, CreateEnumRequest, CreateNumericRequest,
+    GetWalletTransactionsRequest, InfoRequest, ListContractsRequest, ListOffersRequest,
+    ListPeersRequest, ListUtxosRequest, NewAddressRequest, OracleAnnouncementsRequest,
+    SendOfferRequest, SendRequest, SignRequest, SyncRequest, WalletBalanceRequest,
+    WalletSyncRequest,
 };
 use anyhow::anyhow;
 use bitcoin::{Amount, Transaction};
@@ -44,7 +44,6 @@ pub async fn cli_command(
             } else {
                 interactive_contract_input(client).await?
             };
-
             let contract_input = serde_json::to_vec(&contract_input)?;
             let offer = client
                 .send_offer(SendOfferRequest {
@@ -136,7 +135,6 @@ pub async fn cli_command(
                     .iter()
                     .map(|utxo| serde_json::from_slice(utxo).unwrap())
                     .collect::<Vec<LocalOutput>>();
-
                 print!("{}", serde_json::to_string_pretty(&local_outputs).unwrap())
             }
             WalletCommand::Send {
@@ -184,6 +182,51 @@ pub async fn cli_command(
                     serde_json::to_string_pretty(&oracle_announcement).unwrap()
                 )
             }
+            OracleCommand::CreateNumeric {
+                maturity,
+                nb_digits,
+            } => {
+                let response = client
+                    .create_numeric(CreateNumericRequest {
+                        maturity,
+                        nb_digits,
+                    })
+                    .await?
+                    .into_inner();
+                let oracle_announcement: OracleAnnouncement =
+                    serde_json::from_slice(&response.announcement)?;
+                print!(
+                    "{}",
+                    serde_json::to_string_pretty(&oracle_announcement).unwrap()
+                )
+            }
+            OracleCommand::Sign {
+                r#enum: enum_flag,
+                numeric,
+                outcome,
+                event_id,
+            } => {
+                if enum_flag && numeric {
+                    return Err(anyhow!("Cannot specify both --enum and --numeric"));
+                }
+                if !enum_flag && !numeric {
+                    return Err(anyhow!("Must specify either --enum or --numeric"));
+                }
+                let outcome_variant = if enum_flag {
+                    sign_request::Outcome::EnumOutcome(outcome)
+                } else {
+                    let numeric_outcome = outcome.parse::<i64>().map_err(|_| {
+                        anyhow!("Outcome must be a valid integer for numeric events")
+                    })?;
+                    sign_request::Outcome::NumericOutcome(numeric_outcome)
+                };
+                let request = SignRequest {
+                    event_id,
+                    outcome: Some(outcome_variant),
+                };
+                let response = client.sign_announcement(request).await?.into_inner();
+                print!("{}", serde_json::to_string_pretty(&response.signature)?);
+            }
         },
         CliCommand::Peers => {
             let peers_response = client
@@ -208,7 +251,6 @@ pub async fn cli_command(
             println!("Synced.")
         }
     }
-
     Ok(())
 }