2016-12-11 19:30:54 +01:00
|
|
|
// Copyright 2015, 2016 Parity Technologies (UK) Ltd.
|
2016-06-01 19:37:34 +02:00
|
|
|
// This file is part of Parity.
|
|
|
|
|
|
|
|
// Parity is free software: you can redistribute it and/or modify
|
|
|
|
// it under the terms of the GNU General Public License as published by
|
|
|
|
// the Free Software Foundation, either version 3 of the License, or
|
|
|
|
// (at your option) any later version.
|
|
|
|
|
|
|
|
// Parity is distributed in the hope that it will be useful,
|
|
|
|
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
|
|
// GNU General Public License for more details.
|
|
|
|
|
|
|
|
// You should have received a copy of the GNU General Public License
|
|
|
|
// along with Parity. If not, see <http://www.gnu.org/licenses/>.
|
|
|
|
|
2016-11-06 12:51:53 +01:00
|
|
|
//! Signing RPC implementation.
|
2016-06-01 19:37:34 +02:00
|
|
|
|
|
|
|
use std::sync::{Arc, Weak};
|
2016-11-09 13:13:35 +01:00
|
|
|
use transient_hashmap::TransientHashMap;
|
2016-12-10 20:01:04 +01:00
|
|
|
use util::{U256, Mutex, Hashable};
|
2016-11-06 12:51:53 +01:00
|
|
|
|
|
|
|
use ethcore::account_provider::AccountProvider;
|
2016-06-01 19:57:34 +02:00
|
|
|
use ethcore::miner::MinerService;
|
|
|
|
use ethcore::client::MiningBlockChainClient;
|
2016-11-06 12:51:53 +01:00
|
|
|
|
2016-11-09 13:13:35 +01:00
|
|
|
use jsonrpc_core::Error;
|
2016-12-13 14:27:27 +01:00
|
|
|
use jsonrpc_macros::Ready;
|
2016-11-09 13:13:35 +01:00
|
|
|
use v1::helpers::{
|
|
|
|
errors, dispatch,
|
|
|
|
SigningQueue, ConfirmationPromise, ConfirmationResult, ConfirmationPayload, SignerService
|
|
|
|
};
|
2016-11-06 12:51:53 +01:00
|
|
|
use v1::traits::{EthSigning, ParitySigning};
|
2016-11-09 13:13:35 +01:00
|
|
|
use v1::types::{
|
|
|
|
H160 as RpcH160, H256 as RpcH256, U256 as RpcU256, Bytes as RpcBytes, H520 as RpcH520,
|
|
|
|
Either as RpcEither,
|
2016-11-18 11:03:29 +01:00
|
|
|
RichRawTransaction as RpcRichRawTransaction,
|
2016-11-09 13:13:35 +01:00
|
|
|
TransactionRequest as RpcTransactionRequest,
|
|
|
|
ConfirmationPayload as RpcConfirmationPayload,
|
|
|
|
ConfirmationResponse as RpcConfirmationResponse
|
|
|
|
};
|
2016-06-22 15:55:07 +02:00
|
|
|
|
2016-11-06 12:51:53 +01:00
|
|
|
const MAX_PENDING_DURATION: u64 = 60 * 60;
|
|
|
|
|
|
|
|
pub enum DispatchResult {
|
|
|
|
Promise(ConfirmationPromise),
|
2016-11-09 13:13:35 +01:00
|
|
|
Value(RpcConfirmationResponse),
|
2016-06-22 15:55:07 +02:00
|
|
|
}
|
2016-06-01 19:37:34 +02:00
|
|
|
|
|
|
|
/// Implementation of functions that require signing when no trusted signer is used.
|
2016-11-06 12:51:53 +01:00
|
|
|
pub struct SigningQueueClient<C, M> where C: MiningBlockChainClient, M: MinerService {
|
2016-09-21 12:44:49 +02:00
|
|
|
signer: Weak<SignerService>,
|
2016-06-22 21:32:26 +02:00
|
|
|
accounts: Weak<AccountProvider>,
|
2016-06-22 15:55:07 +02:00
|
|
|
client: Weak<C>,
|
2016-06-18 14:55:46 +02:00
|
|
|
miner: Weak<M>,
|
2016-07-19 09:19:58 +02:00
|
|
|
|
|
|
|
pending: Mutex<TransientHashMap<U256, ConfirmationPromise>>,
|
2016-06-01 19:37:34 +02:00
|
|
|
}
|
|
|
|
|
2016-11-06 12:51:53 +01:00
|
|
|
impl<C, M> SigningQueueClient<C, M> where
|
|
|
|
C: MiningBlockChainClient,
|
|
|
|
M: MinerService,
|
|
|
|
{
|
2016-06-01 19:37:34 +02:00
|
|
|
/// Creates a new signing queue client given shared signing queue.
|
2016-09-21 12:44:49 +02:00
|
|
|
pub fn new(signer: &Arc<SignerService>, client: &Arc<C>, miner: &Arc<M>, accounts: &Arc<AccountProvider>) -> Self {
|
2016-11-06 12:51:53 +01:00
|
|
|
SigningQueueClient {
|
2016-09-21 12:44:49 +02:00
|
|
|
signer: Arc::downgrade(signer),
|
2016-06-22 21:32:26 +02:00
|
|
|
accounts: Arc::downgrade(accounts),
|
2016-06-22 15:55:07 +02:00
|
|
|
client: Arc::downgrade(client),
|
2016-06-18 14:55:46 +02:00
|
|
|
miner: Arc::downgrade(miner),
|
2016-07-19 09:19:58 +02:00
|
|
|
pending: Mutex::new(TransientHashMap::new(MAX_PENDING_DURATION)),
|
2016-06-18 14:55:46 +02:00
|
|
|
}
|
|
|
|
}
|
2016-07-05 17:50:46 +02:00
|
|
|
|
|
|
|
fn active(&self) -> Result<(), Error> {
|
|
|
|
// TODO: only call every 30s at most.
|
|
|
|
take_weak!(self.client).keep_alive();
|
|
|
|
Ok(())
|
|
|
|
}
|
2016-06-01 19:37:34 +02:00
|
|
|
|
2016-11-09 13:13:35 +01:00
|
|
|
fn handle_dispatch<OnResponse>(&self, res: Result<DispatchResult, Error>, on_response: OnResponse)
|
|
|
|
where OnResponse: FnOnce(Result<RpcConfirmationResponse, Error>) + Send + 'static
|
|
|
|
{
|
2016-10-15 14:44:08 +02:00
|
|
|
match res {
|
2016-11-09 13:13:35 +01:00
|
|
|
Ok(DispatchResult::Value(result)) => on_response(Ok(result)),
|
2016-10-15 14:44:08 +02:00
|
|
|
Ok(DispatchResult::Promise(promise)) => {
|
|
|
|
promise.wait_for_result(move |result| {
|
2016-11-09 13:13:35 +01:00
|
|
|
on_response(result.unwrap_or_else(|| Err(errors::request_rejected())))
|
2016-10-15 14:44:08 +02:00
|
|
|
})
|
|
|
|
},
|
2016-11-09 13:13:35 +01:00
|
|
|
Err(e) => on_response(Err(e)),
|
2016-10-15 14:44:08 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-11-09 13:13:35 +01:00
|
|
|
fn add_to_queue(&self, payload: ConfirmationPayload) -> Result<DispatchResult, Error> {
|
|
|
|
let client = take_weak!(self.client);
|
|
|
|
let miner = take_weak!(self.miner);
|
|
|
|
let accounts = take_weak!(self.accounts);
|
|
|
|
|
|
|
|
let sender = payload.sender();
|
|
|
|
if accounts.is_unlocked(sender) {
|
2016-11-30 16:11:41 +01:00
|
|
|
return dispatch::execute(&*client, &*miner, &*accounts, payload, dispatch::SignWith::Nothing)
|
|
|
|
.map(|v| v.into_value())
|
|
|
|
.map(DispatchResult::Value);
|
2016-11-09 13:13:35 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
take_weak!(self.signer).add_request(payload)
|
|
|
|
.map(DispatchResult::Promise)
|
|
|
|
.map_err(|_| errors::request_rejected_limit())
|
2016-08-03 10:36:54 +02:00
|
|
|
}
|
|
|
|
|
2016-11-09 13:13:35 +01:00
|
|
|
fn dispatch(&self, payload: RpcConfirmationPayload) -> Result<DispatchResult, Error> {
|
|
|
|
let client = take_weak!(self.client);
|
|
|
|
let miner = take_weak!(self.miner);
|
|
|
|
|
|
|
|
let payload = dispatch::from_rpc(payload, &*client, &*miner);
|
|
|
|
self.add_to_queue(payload)
|
2016-07-19 09:19:58 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-11-06 12:51:53 +01:00
|
|
|
impl<C: 'static, M: 'static> ParitySigning for SigningQueueClient<C, M> where
|
|
|
|
C: MiningBlockChainClient,
|
|
|
|
M: MinerService,
|
2016-07-19 09:19:58 +02:00
|
|
|
{
|
2016-11-09 13:13:35 +01:00
|
|
|
fn post_sign(&self, address: RpcH160, hash: RpcH256) -> Result<RpcEither<RpcU256, RpcConfirmationResponse>, Error> {
|
2016-07-19 09:19:58 +02:00
|
|
|
try!(self.active());
|
2016-11-09 13:13:35 +01:00
|
|
|
self.dispatch(RpcConfirmationPayload::Signature((address, hash).into()))
|
|
|
|
.map(|result| match result {
|
|
|
|
DispatchResult::Value(v) => RpcEither::Or(v),
|
|
|
|
DispatchResult::Promise(promise) => {
|
|
|
|
let id = promise.id();
|
|
|
|
self.pending.lock().insert(id, promise);
|
|
|
|
RpcEither::Either(id.into())
|
|
|
|
},
|
|
|
|
})
|
2016-07-19 09:19:58 +02:00
|
|
|
}
|
|
|
|
|
2016-11-09 13:13:35 +01:00
|
|
|
fn post_transaction(&self, request: RpcTransactionRequest) -> Result<RpcEither<RpcU256, RpcConfirmationResponse>, Error> {
|
2016-07-19 09:19:58 +02:00
|
|
|
try!(self.active());
|
2016-11-09 13:13:35 +01:00
|
|
|
self.dispatch(RpcConfirmationPayload::SendTransaction(request))
|
|
|
|
.map(|result| match result {
|
|
|
|
DispatchResult::Value(v) => RpcEither::Or(v),
|
|
|
|
DispatchResult::Promise(promise) => {
|
|
|
|
let id = promise.id();
|
|
|
|
self.pending.lock().insert(id, promise);
|
|
|
|
RpcEither::Either(id.into())
|
|
|
|
},
|
|
|
|
})
|
2016-07-19 09:19:58 +02:00
|
|
|
}
|
|
|
|
|
2016-11-09 13:13:35 +01:00
|
|
|
fn check_request(&self, id: RpcU256) -> Result<Option<RpcConfirmationResponse>, Error> {
|
2016-07-19 09:19:58 +02:00
|
|
|
try!(self.active());
|
|
|
|
let mut pending = self.pending.lock();
|
2016-11-09 13:13:35 +01:00
|
|
|
let id: U256 = id.into();
|
|
|
|
let res = match pending.get(&id) {
|
|
|
|
Some(ref promise) => match promise.result() {
|
|
|
|
ConfirmationResult::Waiting => { return Ok(None); }
|
|
|
|
ConfirmationResult::Rejected => Err(errors::request_rejected()),
|
|
|
|
ConfirmationResult::Confirmed(rpc_response) => rpc_response.map(Some),
|
|
|
|
},
|
|
|
|
_ => { return Err(errors::request_not_found()); }
|
|
|
|
};
|
|
|
|
pending.remove(&id);
|
|
|
|
res
|
2016-06-01 19:37:34 +02:00
|
|
|
}
|
2016-10-15 14:44:08 +02:00
|
|
|
|
2016-11-09 13:13:35 +01:00
|
|
|
fn decrypt_message(&self, ready: Ready<RpcBytes>, address: RpcH160, data: RpcBytes) {
|
2016-10-15 14:44:08 +02:00
|
|
|
let res = self.active()
|
2016-11-09 13:13:35 +01:00
|
|
|
.and_then(|_| self.dispatch(RpcConfirmationPayload::Decrypt((address, data).into())));
|
|
|
|
// TODO [todr] typed handle_dispatch
|
|
|
|
self.handle_dispatch(res, |response| {
|
|
|
|
match response {
|
|
|
|
Ok(RpcConfirmationResponse::Decrypt(data)) => ready.ready(Ok(data)),
|
|
|
|
Err(e) => ready.ready(Err(e)),
|
|
|
|
e => ready.ready(Err(errors::internal("Unexpected result.", e))),
|
|
|
|
}
|
|
|
|
});
|
2016-10-15 14:44:08 +02:00
|
|
|
}
|
2016-06-01 19:37:34 +02:00
|
|
|
}
|
|
|
|
|
2016-11-06 12:51:53 +01:00
|
|
|
impl<C: 'static, M: 'static> EthSigning for SigningQueueClient<C, M> where
|
2016-06-01 19:57:34 +02:00
|
|
|
C: MiningBlockChainClient,
|
2016-11-06 12:51:53 +01:00
|
|
|
M: MinerService,
|
|
|
|
{
|
2016-12-10 20:01:04 +01:00
|
|
|
fn sign(&self, ready: Ready<RpcH520>, address: RpcH160, data: RpcBytes) {
|
|
|
|
let hash = data.0.sha3().into();
|
2016-11-09 13:13:35 +01:00
|
|
|
let res = self.active().and_then(|_| self.dispatch(RpcConfirmationPayload::Signature((address, hash).into())));
|
|
|
|
self.handle_dispatch(res, |response| {
|
|
|
|
match response {
|
|
|
|
Ok(RpcConfirmationResponse::Signature(signature)) => ready.ready(Ok(signature)),
|
|
|
|
Err(e) => ready.ready(Err(e)),
|
|
|
|
e => ready.ready(Err(errors::internal("Unexpected result.", e))),
|
|
|
|
}
|
|
|
|
});
|
2016-06-01 19:37:34 +02:00
|
|
|
}
|
|
|
|
|
2016-11-09 13:13:35 +01:00
|
|
|
fn send_transaction(&self, ready: Ready<RpcH256>, request: RpcTransactionRequest) {
|
|
|
|
let res = self.active().and_then(|_| self.dispatch(RpcConfirmationPayload::SendTransaction(request)));
|
|
|
|
self.handle_dispatch(res, |response| {
|
|
|
|
match response {
|
|
|
|
Ok(RpcConfirmationResponse::SendTransaction(hash)) => ready.ready(Ok(hash)),
|
|
|
|
Err(e) => ready.ready(Err(e)),
|
|
|
|
e => ready.ready(Err(errors::internal("Unexpected result.", e))),
|
|
|
|
}
|
|
|
|
});
|
2016-07-19 09:19:58 +02:00
|
|
|
}
|
|
|
|
|
2016-11-18 11:03:29 +01:00
|
|
|
fn sign_transaction(&self, ready: Ready<RpcRichRawTransaction>, request: RpcTransactionRequest) {
|
2016-11-09 13:13:35 +01:00
|
|
|
let res = self.active().and_then(|_| self.dispatch(RpcConfirmationPayload::SignTransaction(request)));
|
|
|
|
self.handle_dispatch(res, |response| {
|
|
|
|
match response {
|
2016-11-18 11:03:29 +01:00
|
|
|
Ok(RpcConfirmationResponse::SignTransaction(tx)) => ready.ready(Ok(tx)),
|
2016-11-09 13:13:35 +01:00
|
|
|
Err(e) => ready.ready(Err(e)),
|
|
|
|
e => ready.ready(Err(errors::internal("Unexpected result.", e))),
|
|
|
|
}
|
|
|
|
});
|
2016-07-19 09:19:58 +02:00
|
|
|
}
|
2016-06-15 00:17:23 +02:00
|
|
|
}
|