Implement miner_getWork RPC API

Adjust fields of Work as follows:
* Change block_hash field to pow_hash
* Change score field to target
* Remove block_number field

Author: kseo

core/src/lib.rs

@@ -59,7 +59,7 @@ extern crate util_error;
 extern crate log;
 
 mod account_provider;
-mod block;
+pub mod block;
 mod blockchain;
 mod blockchain_info;
 mod client;

core/src/miner/miner.rs

@@ -622,6 +622,19 @@ impl MinerService for Miner {
         }
     }
 
+    fn map_sealing_work<C, F, T>(&self, client: &C, f: F) -> Option<T>
+    where
+        C: AccountData + BlockChain + BlockProducer,
+        F: FnOnce(&ClosedBlock) -> T, {
+        ctrace!(MINER, "map_sealing_work: entering");
+        self.prepare_work_sealing(client);
+        ctrace!(MINER, "map_sealing_work: sealing prepared");
+        let mut sealing_work = self.sealing_work.lock();
+        let ret = sealing_work.queue.use_last_ref();
+        ctrace!(MINER, "map_sealing_work: leaving use_last_ref={:?}", ret.as_ref().map(|b| b.block().header().hash()));
+        ret.map(f)
+    }
+
     fn submit_seal<C: ImportSealedBlock>(&self, chain: &C, block_hash: H256, seal: Vec<Bytes>) -> Result<(), Error> {
         let result = if let Some(b) = self.sealing_work.lock().queue.take_used_if(|b| &b.hash() == &block_hash) {
             ctrace!(

core/src/miner/mod.rs

@@ -23,6 +23,7 @@ use ctypes::{Address, Bytes, H256, U256};
 
 pub use self::miner::{Miner, MinerOptions};
 use super::account_provider::SignError;
+use super::block::ClosedBlock;
 use super::client::{AccountData, BlockChain, BlockProducer, ImportSealedBlock, MiningBlockChainClient};
 use super::error::Error;
 use super::parcel::{SignedParcel, UnverifiedParcel};
@@ -80,6 +81,13 @@ pub trait MinerService: Send + Sync {
     /// Will check the seal, but not actually insert the block into the chain.
     fn submit_seal<C: ImportSealedBlock>(&self, chain: &C, pow_hash: H256, seal: Vec<Bytes>) -> Result<(), Error>;
 
+    /// Get the sealing work package and if `Some`, apply some transform.
+    fn map_sealing_work<C, F, T>(&self, client: &C, f: F) -> Option<T>
+    where
+        C: AccountData + BlockChain + BlockProducer,
+        F: FnOnce(&ClosedBlock) -> T,
+        Self: Sized;
+
     /// Imports parcels to mem pool.
     fn import_external_parcels<C: MiningBlockChainClient>(
         &self,

rpc/src/v1/errors.rs

@@ -14,13 +14,16 @@
 // You should have received a copy of the GNU Affero General Public License
 // along with this program.  If not, see <https://www.gnu.org/licenses/>.
 
+use std::fmt;
+
 use ccore::Error as CoreError;
 use kvdb::Error as KVDBError;
 use rlp::DecoderError;
 
 use jsonrpc_core::{Error, ErrorCode, Value};
 
 mod codes {
+    pub const NO_AUTHOR: i64 = -32002;
     pub const NO_WORK_REQUIRED: i64 = -32004;
     pub const UNKNOWN_ERROR: i64 = -32009;
     pub const PARCEL_ERROR: i64 = -32010;
@@ -61,6 +64,14 @@ pub fn rlp(error: DecoderError) -> Error {
     }
 }
 
+pub fn no_author() -> Error {
+    Error {
+        code: ErrorCode::ServerError(codes::NO_AUTHOR),
+        message: "Author not configured. Run Parity with --author to configure.".into(),
+        data: None,
+    }
+}
+
 pub fn no_work_required() -> Error {
     Error {
         code: ErrorCode::ServerError(codes::NO_WORK_REQUIRED),
@@ -76,3 +87,14 @@ pub fn network_disabled() -> Error {
         data: None,
     }
 }
+
+/// Internal error signifying a logic error in code.
+/// Should not be used when function can just fail
+/// because of invalid parameters or incomplete node state.
+pub fn internal<T: fmt::Debug>(error: &str, data: T) -> Error {
+    Error {
+        code: ErrorCode::InternalError,
+        message: format!("Internal error occurred: {}", error),
+        data: Some(Value::String(format!("{:?}", data))),
+    }
+}

rpc/src/v1/impls/miner.rs

@@ -16,6 +16,7 @@
 
 use std::sync::Arc;
 
+use ccore::block::IsBlock;
 use ccore::{self, Client, MinerService};
 use ctypes::H256;
 use jsonrpc_core::Result;
@@ -44,7 +45,21 @@ impl Miner for MinerClient {
             cwarn!(MINER, "Cannot give work package - engine seals internally.");
             return Err(errors::no_work_required())
         }
-        unimplemented!();
+        if self.miner.author().is_zero() {
+            cwarn!(MINER, "Cannot give work package - no author is configured. Use --author to configure!");
+            return Err(errors::no_author())
+        }
+        self.miner
+            .map_sealing_work(&*self.client, |b| {
+                let pow_hash = b.hash();
+                let target = self.client.engine().score_to_target(b.block().header().score());
+
+                Ok(Work {
+                    pow_hash,
+                    target,
+                })
+            })
+            .unwrap_or(Err(errors::internal("No work found.", "")))
     }
 
     fn submit_work(&self, pow_hash: H256, seal: Vec<Bytes>) -> Result<bool> {

rpc/src/v1/types/work.rs

@@ -19,7 +19,6 @@ use ctypes::{H256, U256};
 #[derive(Debug, Serialize)]
 #[serde(rename_all = "camelCase")]
 pub struct Work {
-    pub block_hash: H256,
-    pub score: U256,
-    pub block_number: u64,
+    pub pow_hash: H256,
+    pub target: U256,
 }