Updated Dash Masternode RPC Calls

README.md

@@ -26,7 +26,7 @@ use dashcore_rpc::{Auth, Client, RpcApi};
 
 fn main() {
 
-    let rpc = Client::new("localhost:19998".to_string(),
+    let rpc = Client::new("localhost:19998",
                           Auth::UserPass("<FILL RPC USERNAME>".to_string(),
                                          "<FILL RPC PASSWORD>".to_string())).unwrap();
     let best_block_hash = rpc.get_best_block_hash().unwrap();

client/examples/connect_to_masternode.rs

@@ -3,29 +3,50 @@ extern crate dashcore_rpc;
 use dashcore_rpc::{Auth, Client, RpcApi};
 
 fn main() {
-    let rpc = Client::new(
-        "localhost:19998".to_string(),
+    let rpc = Client::new("127.0.0.1:19998",
         Auth::UserPass("dashrpc".to_string(), "rpcpassword".to_string()),
     )
     .unwrap();
 
-    // Get Dash network info
+    // // Get Dash network info
     let network_info = rpc.get_network_info().unwrap();
     println!("\nDash network info: \n{:?}", network_info);
 
-    // Get best block hash
+    // // Get best block hash
     let best_block_hash = rpc.get_best_block_hash().unwrap();
     println!("\n\nBest block hash: \n{}", best_block_hash);
 
-    // Get block count
+    // // Get block count
     let block_count = rpc.get_block_count().unwrap();
     println!("\n\nBlock count: \n{}", block_count);
 
-    // Get block hash (for the a specified block height)
+    // // Get block hash (for the a specified block height)
     let block_hash = rpc.get_block_hash(block_count).unwrap();
-    println!("\n\nBlock hash at block height \n{}: {}", block_count, block_hash);
+    println!("\n\nBlock hash at block height {}: \n{}", block_count, block_hash);
 
     // Get masternode count
     let masternode_count = rpc.get_masternode_count().unwrap();
     println!("\n\nMasternode Count: \n{:?}", masternode_count);
+
+
+    // Get masternode list
+    let mn_list = rpc.get_masternode_list().unwrap();
+    println!("\n\nMasternode List: \n{:?}", mn_list);
+
+    // Get masternode outputs
+    let mn_outputs = rpc.get_masternode_outputs().unwrap();
+    println!("\n\nMasternode Outputs: \n{:?}", mn_outputs);
+
+    // Get masternode payments 
+    let mn_payments = rpc.get_masternode_payments().unwrap();
+    println!("\n\nMasternode Payments: \n{:?}", mn_payments);
+
+    // Get masternode status
+    let mn_status = rpc.get_masternode_status().unwrap();
+    println!("\n\nMasternode Status: \n{:?}", mn_status);
+
+    // Get masternode winners
+    let mn_winners = rpc.get_masternode_winners("10", "").unwrap();
+    println!("\n\nMasternode Winners: \n{:?}", mn_winners);
+
 }

client/src/client.rs

@@ -1168,9 +1168,40 @@ pub trait RpcApi: Sized {
     fn get_masternode_count(&self) -> Result<json::GetMasternodeCountResult> {
         self.call("masternode", &["count".into()])
     }
+
+
+    /// Returns a list of known masternodes
+     fn get_masternode_list(&self) -> Result<HashMap<String, json::GetMasternodeListJSON>>{ 
+        let mut args = ["list".into(), "json".into()];
+        self.call::<HashMap<String, json::GetMasternodeListJSON>>("masternode", handle_defaults(&mut args, &[null()])) 
+    }
+
+    /// Returns masternode compatible outputs
+    fn get_masternode_outputs(&self) -> Result<HashMap<String, String>>{ 
+            let mut args = ["outputs".into()];
+            self.call::<HashMap<String, String>>("masternode", handle_defaults(&mut args, &[null()])) 
+    }
+
+    /// Returns an array of deterministic masternodes and their payments for the specified block
+    fn get_masternode_payments(&self) -> Result<Vec<json::GetMasternodePaymentsResult>>{ 
+            let mut args = ["payments".into()];
+            self.call::<Vec<json::GetMasternodePaymentsResult>>("masternode", handle_defaults(&mut args, &[null()])) 
+    }
+
+    /// Returns masternode status information
+    fn get_masternode_status(&self) -> Result<json::GetMasternodeStatusResult> {
+            self.call("masternode", &["status".into()])
+    }
+
+    /// Returns the list of masternode winners
+    fn get_masternode_winners(&self, count: &str, filter: &str) -> Result<HashMap<String, String>> {
+            self.call("masternode", &["winners".into(), count.into(), filter.into()])
+    }
+
+
 }
 
-/// Client implements a JSON-RPC client for the Bitcoin Core daemon or compatible APIs.
+/// Client implements a JSON-RPC client for the Dash Core daemon or compatible APIs.
 pub struct Client {
     client: jsonrpc::client::Client,
 }

integration_test/src/main.rs

@@ -213,6 +213,11 @@ fn main() {
     test_add_ban(&cl);
     test_set_network_active(&cl);
     test_stop(cl);
+    test_get_masternode_count(cl);
+    test_get_masternode_list(cl);
+    test_get_masternode_outputs(cl);
+    test_get_masternode_payments(cl);
+    test_get_masternode_status(cl);
 }
 
 fn test_get_network_info(cl: &Client) {
@@ -1136,3 +1141,39 @@ fn test_getblocktemplate(cl: &Client) {
 fn test_stop(cl: Client) {
     println!("Stopping: '{}'", cl.stop().unwrap());
 }
+
+
+// ---------------------- Masternode RPC tests---------------------
+
+fn test_get_masternode_count(cl: &Client) {
+    let masternode_count = rpc.get_masternode_count().unwrap();
+    assert!(masternode_count.total > 0);
+    assert!(masternode_count.enabled > 0);
+    assert!(masternode_count.total >= masternode_count.enabled);
+}
+
+fn test_get_masternode_list(cl: &Client) {
+    let masternode_list = rpc.get_masternode_list().unwrap();
+}
+
+fn test_get_masternode_outputs(cl: &Client) {
+    let masternode_outputs = rpc.get_masternode_outputs().unwrap();
+}
+
+fn test_get_masternode_payments(cl: &Client) {
+    let masternode_payments = rpc.get_masternode_payments().unwrap();
+    assert!(masternode_payments[0].height > 0);
+    assert!(masternode_payments[0].amount > 0);
+    assert!(masternode_payments[0].masternodes[0].amount > 0);
+    assert!(masternode_payments[0].masternodes[0].payees[0].amount > 0);
+    assert_eq!(masternode_payments[0].amount, masternode_payments[0].masternodes[0].amount);
+    assert_eq!(masternode_payments[0].amount, masternode_payments[0].masternodes[0].payees[0].amount);
+}
+
+fn test_get_masternode_status(cl: &Client) {
+    let masternode_status = rpc.get_masternode_status().unwrap();
+}
+
+fn test_get_masternode_winners(cl: &Client) {
+    let masternode_winners = rpc.get_masternode_winners("10", "").unwrap();
+}

json/src/lib.rs

@@ -1986,6 +1986,91 @@ pub struct GetMasternodeCountResult {
     pub enabled: u32,
 }
 
+#[derive(Clone, PartialEq, Eq, Debug, Deserialize, Serialize)]
+pub struct GetMasternodeListJSON {
+    #[serde(rename = "proTxHash")]
+    pub pro_tx_hash: String,
+    pub address: String,
+    pub payee: String,
+    pub status: String,
+    #[serde(rename = "lastpaidtime")]
+    pub last_paid_time: u32,
+    #[serde(rename = "lastpaidblock")]
+    pub last_paid_block: u32,
+    #[serde(rename = "owneraddress")]
+    pub owner_address: String,
+    #[serde(rename = "votingaddress")]
+    pub voting_address: String,
+    #[serde(rename = "collateraladdress")]
+    pub collateral_address: String,
+    #[serde(rename = "pubkeyoperator")]
+    pub pubkey_operator: String,
+}
+
+#[derive(Clone, PartialEq, Eq, Debug, Deserialize, Serialize)]
+pub struct Payee {
+    pub address: String,
+    pub script: String,
+    pub amount: u32,
+}
+
+#[derive(Clone, PartialEq, Eq, Debug, Deserialize, Serialize)]
+pub struct Masternode {
+    #[serde(rename = "proTxHash")]
+    pub pro_tx_hash: String,
+    pub amount: u32,
+    pub payees: Vec<Payee>,
+}
+
+#[derive(Clone, PartialEq, Eq, Debug, Deserialize, Serialize)]
+pub struct GetMasternodePaymentsResult {
+    pub height: u32,
+    #[serde(rename = "blockhash")]
+    pub block_hash: String,
+    pub amount: u32,
+    pub masternodes: Vec<Masternode>,
+}
+
+#[derive(Clone, PartialEq, Eq, Debug, Deserialize, Serialize)]
+pub struct DMNState {
+    pub service: String,
+    #[serde(rename = "registeredHeight")]
+    pub registered_height: u32,
+    #[serde(rename = "lastPaidHeight")]
+    pub last_paid_height: u32,
+    #[serde(rename = "PoSePenalty")]
+    pub pose_penalty: u32,
+    #[serde(rename = "PoSeRevivedHeight")]
+    pub pose_revived_height: u32,
+    #[serde(rename = "PoSeBanHeight")]
+    pub pose_ban_height: i32,
+    #[serde(rename = "revocationReason")]
+    pub revocation_reason: u32,
+    #[serde(rename = "ownerAddress")]
+    pub owner_address: String,
+    #[serde(rename = "votingAddress")]
+    pub voting_address: String,
+    #[serde(rename = "payoutAddress")]
+    pub payout_address: String,
+    #[serde(rename = "pubKeyOperator")]
+    pub pubkey_operator: String,
+}
+
+#[derive(Clone, PartialEq, Eq, Debug, Deserialize, Serialize)]
+pub struct GetMasternodeStatusResult {
+    pub outpoint: String,
+    pub service: String,
+    #[serde(rename = "proTxHash")]
+    pub pro_tx_hash: String,
+    #[serde(rename = "collateralHash")]
+    pub collateral_hash: String,
+    #[serde(rename = "collateralIndex")]
+    pub collateral_index: u32,
+    #[serde(rename = "dmnState")]
+    pub dmn_state: DMNState,
+    pub state: String,
+    pub status: String,
+}
 
 // Custom deserializer functions.