darkfid: continue working on exporting keypair to external file

src/bin/darkfid.rs

@@ -75,7 +75,7 @@ impl RequestHandler for Darkfid {
             Some("key_gen") => return self.key_gen(req.id, req.params).await,
             Some("get_key") => return self.get_key(req.id, req.params).await,
             Some("get_keys") => return self.get_keys(req.id, req.params).await,
-            Some("export_keypair") => return self.get_keys(req.id, req.params).await,
+            Some("export_keypair") => return self.export_keypair(req.id, req.params).await,
             Some("set_default_address") => {
                 return self.set_default_address(req.id, req.params).await
             }
@@ -183,13 +183,42 @@ impl Darkfid {
 
     // --> {"method": "export_keypair", "params": "path/"}
     // <-- {"result": true}
-    async fn export_keypair(&self, _id: Value, _params: Value) -> JsonResult {
-        // TODO
-        unimplemented!()
+    async fn export_keypair(&self, id: Value, params: Value) -> JsonResult {
+        let args = params.as_array();
+
+        if args.is_none() {
+            return JsonResult::Err(jsonerr(InvalidParams, None, id))
+        }
+
+        let arg = args.unwrap()[0].clone();
+
+        if arg.as_str().is_none() &&
+            expand_path(arg.as_str().unwrap()).is_ok() &&
+            expand_path(arg.as_str().unwrap()).unwrap().to_str().is_some()
+        {
+            return JsonResult::Err(jsonerr(InvalidParams, Some("invalid path".into()), id))
+        }
+
+        let path = expand_path(arg.as_str().unwrap()).unwrap();
+        let path = path.to_str().unwrap();
+
+        let result: Result<()> = async {
+            let keypair: String =
+                serde_json::to_string(&self.client.lock().await.main_keypair.secret.to_bytes())?;
+            std::fs::write(path, &keypair)?;
+            Ok(())
+        }
+        .await;
+
+        match result {
+            Ok(_) => JsonResult::Resp(jsonresp(json!(true), id)),
+            Err(err) => JsonResult::Err(jsonerr(ServerError(-32004), Some(err.to_string()), id)),
+        }
     }
 
     // --> {"method": "set_default_address", "params":
-    // "vdNS7oBj7KvsMWWmo9r96SV4SqATLrGsH2a3PGpCfJC"} <-- {"result": true}
+    // "vdNS7oBj7KvsMWWmo9r96SV4SqATLrGsH2a3PGpCfJC"}
+    // <-- {"result": true}
     async fn set_default_address(&self, _id: Value, _params: Value) -> JsonResult {
         // TODO
         unimplemented!()

src/bin/drk.rs

@@ -110,15 +110,15 @@ impl Drk {
     // --> {"jsonrpc": "2.0", "method": "set_default_address", "params":
     // "vdNS7oBj7KvsMWWmo9r96SV4SqATLrGsH2a3PGpCfJC", "id": 42} <-- {"jsonrpc": "2.0", "result":
     // true, "id": 42}
-    async fn set_default_address(&self, address: String) -> Result<Value> {
-        let req = jsonrpc::request(json!("set_default_address"), json!(address));
+    async fn set_default_address(&self, address: &str) -> Result<Value> {
+        let req = jsonrpc::request(json!("set_default_address"), json!([address]));
         Ok(self.request(req).await?)
     }
 
     // --> {"jsonrpc": "2.0", "method": "export_keypair", "params": "path/", "id": 42}
     // <-- {"jsonrpc": "2.0", "result": true, "id": 42}
-    async fn export_keypair(&self, path: String) -> Result<Value> {
-        let req = jsonrpc::request(json!("export_keypair"), json!(path));
+    async fn export_keypair(&self, path: &str) -> Result<Value> {
+        let req = jsonrpc::request(json!("export_keypair"), json!([path]));
         Ok(self.request(req).await?)
     }
 
@@ -267,13 +267,13 @@ async fn start(config: &DrkConfig, options: CliDrk) -> Result<()> {
 
             if set_default_address.is_some() {
                 let default_address = set_default_address.unwrap();
-                client.set_default_address(default_address).await?;
+                client.set_default_address(&default_address).await?;
                 return Ok(())
             }
 
             if export_keypair.is_some() {
                 let path = export_keypair.unwrap();
-                client.export_keypair(path).await?;
+                client.export_keypair(&path).await?;
                 return Ok(())
             }
         }

src/rpc/jsonrpc.rs

@@ -21,6 +21,7 @@ pub enum ErrorCode {
     InternalError,
     KeyGenError,
     GetAddressesError,
+    CreateFile,
     InvalidAmountParam,
     InvalidNetworkParam,
     InvalidTokenIdParam,
@@ -39,6 +40,7 @@ impl ErrorCode {
             ErrorCode::InternalError => -32603,
             ErrorCode::KeyGenError => -32002,
             ErrorCode::GetAddressesError => -32003,
+            ErrorCode::CreateFile => -32004,
             ErrorCode::InvalidAmountParam => -32010,
             ErrorCode::InvalidNetworkParam => -32011,
             ErrorCode::InvalidTokenIdParam => -32012,
@@ -57,6 +59,7 @@ impl ErrorCode {
             ErrorCode::InternalError => "Internal error",
             ErrorCode::KeyGenError => "Key gen error",
             ErrorCode::GetAddressesError => "get addresses error",
+            ErrorCode::CreateFile => "error creating a file",
             ErrorCode::InvalidAmountParam => "Invalid amount param",
             ErrorCode::InvalidNetworkParam => "Invalid network param",
             ErrorCode::InvalidTokenIdParam => "Invalid token id param",