245 lines
8.4 KiB
Rust
245 lines
8.4 KiB
Rust
// Copyright 2015-2017 Parity Technologies (UK) Ltd.
|
|
// 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/>.
|
|
|
|
//! Signing RPC implementation.
|
|
|
|
use std::sync::{Arc, Weak};
|
|
use transient_hashmap::TransientHashMap;
|
|
use util::{U256, Mutex};
|
|
|
|
use ethcore::account_provider::AccountProvider;
|
|
|
|
use futures::{self, future, BoxFuture, Future};
|
|
use jsonrpc_core::Error;
|
|
use v1::helpers::{
|
|
errors,
|
|
DefaultAccount,
|
|
SigningQueue, ConfirmationPromise, ConfirmationResult, ConfirmationPayload, SignerService
|
|
};
|
|
use v1::helpers::dispatch::{self, Dispatcher};
|
|
use v1::metadata::Metadata;
|
|
use v1::traits::{EthSigning, ParitySigning};
|
|
use v1::types::{
|
|
H160 as RpcH160, H256 as RpcH256, U256 as RpcU256, Bytes as RpcBytes, H520 as RpcH520,
|
|
Either as RpcEither,
|
|
RichRawTransaction as RpcRichRawTransaction,
|
|
TransactionRequest as RpcTransactionRequest,
|
|
ConfirmationPayload as RpcConfirmationPayload,
|
|
ConfirmationResponse as RpcConfirmationResponse
|
|
};
|
|
|
|
const MAX_PENDING_DURATION: u64 = 60 * 60;
|
|
|
|
enum DispatchResult {
|
|
Promise(ConfirmationPromise),
|
|
Value(RpcConfirmationResponse),
|
|
}
|
|
|
|
/// Implementation of functions that require signing when no trusted signer is used.
|
|
pub struct SigningQueueClient<D> {
|
|
signer: Weak<SignerService>,
|
|
accounts: Weak<AccountProvider>,
|
|
dispatcher: D,
|
|
pending: Arc<Mutex<TransientHashMap<U256, ConfirmationPromise>>>,
|
|
}
|
|
|
|
fn handle_dispatch<OnResponse>(res: Result<DispatchResult, Error>, on_response: OnResponse)
|
|
where OnResponse: FnOnce(Result<RpcConfirmationResponse, Error>) + Send + 'static
|
|
{
|
|
match res {
|
|
Ok(DispatchResult::Value(result)) => on_response(Ok(result)),
|
|
Ok(DispatchResult::Promise(promise)) => {
|
|
promise.wait_for_result(move |result| {
|
|
on_response(result.unwrap_or_else(|| Err(errors::request_rejected())))
|
|
})
|
|
},
|
|
Err(e) => on_response(Err(e)),
|
|
}
|
|
}
|
|
|
|
impl<D: Dispatcher + 'static> SigningQueueClient<D> {
|
|
/// Creates a new signing queue client given shared signing queue.
|
|
pub fn new(signer: &Arc<SignerService>, dispatcher: D, accounts: &Arc<AccountProvider>) -> Self {
|
|
SigningQueueClient {
|
|
signer: Arc::downgrade(signer),
|
|
accounts: Arc::downgrade(accounts),
|
|
dispatcher: dispatcher,
|
|
pending: Arc::new(Mutex::new(TransientHashMap::new(MAX_PENDING_DURATION))),
|
|
}
|
|
}
|
|
|
|
fn dispatch(&self, payload: RpcConfirmationPayload, default_account: DefaultAccount) -> BoxFuture<DispatchResult, Error> {
|
|
let setup = move || {
|
|
let accounts = take_weak!(self.accounts);
|
|
let default_account = default_account;
|
|
let default_account = match default_account {
|
|
DefaultAccount::Provided(acc) => acc,
|
|
DefaultAccount::ForDapp(dapp) => accounts.default_address(dapp).ok().unwrap_or_default(),
|
|
};
|
|
|
|
Ok((self.dispatcher.clone(), accounts, default_account))
|
|
};
|
|
|
|
let weak_signer = self.signer.clone();
|
|
future::done(setup())
|
|
.and_then(move |(dispatcher, accounts, default_account)| {
|
|
dispatch::from_rpc(payload, default_account, &dispatcher)
|
|
.and_then(move |payload| {
|
|
let sender = payload.sender();
|
|
if accounts.is_unlocked(sender) {
|
|
dispatch::execute(dispatcher, &accounts, payload, dispatch::SignWith::Nothing)
|
|
.map(|v| v.into_value())
|
|
.map(DispatchResult::Value)
|
|
.boxed()
|
|
} else {
|
|
future::lazy(move ||
|
|
take_weak!(weak_signer).add_request(payload)
|
|
.map(DispatchResult::Promise)
|
|
.map_err(|_| errors::request_rejected_limit())
|
|
).boxed()
|
|
}
|
|
})
|
|
})
|
|
.boxed()
|
|
}
|
|
}
|
|
|
|
impl<D: Dispatcher + 'static> ParitySigning for SigningQueueClient<D> {
|
|
type Metadata = Metadata;
|
|
|
|
fn post_sign(&self, address: RpcH160, data: RpcBytes) -> BoxFuture<RpcEither<RpcU256, RpcConfirmationResponse>, Error> {
|
|
let pending = self.pending.clone();
|
|
self.dispatch(RpcConfirmationPayload::Signature((address.clone(), data).into()), DefaultAccount::Provided(address.into()))
|
|
.map(move |result| match result {
|
|
DispatchResult::Value(v) => RpcEither::Or(v),
|
|
DispatchResult::Promise(promise) => {
|
|
let id = promise.id();
|
|
pending.lock().insert(id, promise);
|
|
RpcEither::Either(id.into())
|
|
},
|
|
})
|
|
.boxed()
|
|
}
|
|
|
|
fn post_transaction(&self, meta: Metadata, request: RpcTransactionRequest) -> BoxFuture<RpcEither<RpcU256, RpcConfirmationResponse>, Error> {
|
|
let pending = self.pending.clone();
|
|
self.dispatch(RpcConfirmationPayload::SendTransaction(request), meta.into())
|
|
.map(move |result| match result {
|
|
DispatchResult::Value(v) => RpcEither::Or(v),
|
|
DispatchResult::Promise(promise) => {
|
|
let id = promise.id();
|
|
pending.lock().insert(id, promise);
|
|
RpcEither::Either(id.into())
|
|
},
|
|
})
|
|
.boxed()
|
|
}
|
|
|
|
fn check_request(&self, id: RpcU256) -> Result<Option<RpcConfirmationResponse>, Error> {
|
|
let mut pending = self.pending.lock();
|
|
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
|
|
}
|
|
|
|
fn decrypt_message(&self, address: RpcH160, data: RpcBytes) -> BoxFuture<RpcBytes, Error> {
|
|
let res = self.dispatch(RpcConfirmationPayload::Decrypt((address.clone(), data).into()), address.into());
|
|
|
|
let (ready, p) = futures::oneshot();
|
|
|
|
// when dispatch is complete
|
|
res.then(move |res| {
|
|
// register callback via the oneshot sender.
|
|
handle_dispatch(res, move |response| {
|
|
match response {
|
|
Ok(RpcConfirmationResponse::Decrypt(data)) => ready.complete(Ok(data)),
|
|
Err(e) => ready.complete(Err(e)),
|
|
e => ready.complete(Err(errors::internal("Unexpected result.", e))),
|
|
}
|
|
});
|
|
|
|
// and wait for that to resolve.
|
|
p.then(|result| futures::done(result.expect("Ready is never dropped nor canceled."))).boxed()
|
|
}).boxed()
|
|
}
|
|
}
|
|
|
|
impl<D: Dispatcher + 'static> EthSigning for SigningQueueClient<D> {
|
|
type Metadata = Metadata;
|
|
|
|
fn sign(&self, address: RpcH160, data: RpcBytes) -> BoxFuture<RpcH520, Error> {
|
|
let res = self.dispatch(RpcConfirmationPayload::Signature((address.clone(), data).into()), address.into());
|
|
|
|
let (ready, p) = futures::oneshot();
|
|
|
|
res.then(move |res| {
|
|
handle_dispatch(res, move |response| {
|
|
match response {
|
|
Ok(RpcConfirmationResponse::Signature(sig)) => ready.complete(Ok(sig)),
|
|
Err(e) => ready.complete(Err(e)),
|
|
e => ready.complete(Err(errors::internal("Unexpected result.", e))),
|
|
}
|
|
});
|
|
|
|
p.then(|result| futures::done(result.expect("Ready is never dropped nor canceled."))).boxed()
|
|
}).boxed()
|
|
}
|
|
|
|
fn send_transaction(&self, meta: Metadata, request: RpcTransactionRequest) -> BoxFuture<RpcH256, Error> {
|
|
let res = self.dispatch(RpcConfirmationPayload::SendTransaction(request), meta.into());
|
|
|
|
let (ready, p) = futures::oneshot();
|
|
|
|
res.then(move |res| {
|
|
handle_dispatch(res, move |response| {
|
|
match response {
|
|
Ok(RpcConfirmationResponse::SendTransaction(hash)) => ready.complete(Ok(hash)),
|
|
Err(e) => ready.complete(Err(e)),
|
|
e => ready.complete(Err(errors::internal("Unexpected result.", e))),
|
|
}
|
|
});
|
|
|
|
p.then(|result| futures::done(result.expect("Ready is never dropped nor canceled."))).boxed()
|
|
}).boxed()
|
|
}
|
|
|
|
fn sign_transaction(&self, meta: Metadata, request: RpcTransactionRequest) -> BoxFuture<RpcRichRawTransaction, Error> {
|
|
let res = self.dispatch(RpcConfirmationPayload::SignTransaction(request), meta.into());
|
|
|
|
let (ready, p) = futures::oneshot();
|
|
|
|
res.then(move |res| {
|
|
handle_dispatch(res, move |response| {
|
|
match response {
|
|
Ok(RpcConfirmationResponse::SignTransaction(tx)) => ready.complete(Ok(tx)),
|
|
Err(e) => ready.complete(Err(e)),
|
|
e => ready.complete(Err(errors::internal("Unexpected result.", e))),
|
|
}
|
|
});
|
|
|
|
p.then(|result| futures::done(result.expect("Ready is never dropped nor canceled."))).boxed()
|
|
}).boxed()
|
|
}
|
|
}
|