280 lines
9.6 KiB
Rust
280 lines
9.6 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/>.
|
|
|
|
use std::fmt::Debug;
|
|
use std::ops::Deref;
|
|
use rlp::{self, Stream};
|
|
use util::{Address, H520, H256, U256, Uint, Bytes};
|
|
use util::bytes::ToPretty;
|
|
use util::sha3::Hashable;
|
|
|
|
use ethkey::Signature;
|
|
use ethcore::miner::MinerService;
|
|
use ethcore::client::MiningBlockChainClient;
|
|
use ethcore::transaction::{Action, SignedTransaction, PendingTransaction, Transaction};
|
|
use ethcore::account_provider::AccountProvider;
|
|
|
|
use jsonrpc_core::Error;
|
|
use v1::helpers::{errors, TransactionRequest, FilledTransactionRequest, ConfirmationPayload};
|
|
use v1::types::{
|
|
H256 as RpcH256, H520 as RpcH520, Bytes as RpcBytes,
|
|
RichRawTransaction as RpcRichRawTransaction,
|
|
ConfirmationPayload as RpcConfirmationPayload,
|
|
ConfirmationResponse,
|
|
SignRequest as RpcSignRequest,
|
|
DecryptRequest as RpcDecryptRequest,
|
|
};
|
|
|
|
pub const DEFAULT_MAC: [u8; 2] = [0, 0];
|
|
|
|
type AccountToken = String;
|
|
|
|
#[derive(Debug, Clone, PartialEq)]
|
|
pub enum SignWith {
|
|
Nothing,
|
|
Password(String),
|
|
Token(AccountToken),
|
|
}
|
|
|
|
#[derive(Debug)]
|
|
pub enum WithToken<T: Debug> {
|
|
No(T),
|
|
Yes(T, AccountToken),
|
|
}
|
|
|
|
impl<T: Debug> Deref for WithToken<T> {
|
|
type Target = T;
|
|
|
|
fn deref(&self) -> &Self::Target {
|
|
match *self {
|
|
WithToken::No(ref v) => v,
|
|
WithToken::Yes(ref v, _) => v,
|
|
}
|
|
}
|
|
}
|
|
|
|
impl<T: Debug> WithToken<T> {
|
|
pub fn map<S, F>(self, f: F) -> WithToken<S> where
|
|
S: Debug,
|
|
F: FnOnce(T) -> S,
|
|
{
|
|
match self {
|
|
WithToken::No(v) => WithToken::No(f(v)),
|
|
WithToken::Yes(v, token) => WithToken::Yes(f(v), token),
|
|
}
|
|
}
|
|
|
|
pub fn into_value(self) -> T {
|
|
match self {
|
|
WithToken::No(v) => v,
|
|
WithToken::Yes(v, _) => v,
|
|
}
|
|
}
|
|
}
|
|
|
|
impl<T: Debug> From<(T, AccountToken)> for WithToken<T> {
|
|
fn from(tuple: (T, AccountToken)) -> Self {
|
|
WithToken::Yes(tuple.0, tuple.1)
|
|
}
|
|
}
|
|
|
|
pub fn execute<C, M>(client: &C, miner: &M, accounts: &AccountProvider, payload: ConfirmationPayload, pass: SignWith) -> Result<WithToken<ConfirmationResponse>, Error>
|
|
where C: MiningBlockChainClient, M: MinerService
|
|
{
|
|
match payload {
|
|
ConfirmationPayload::SendTransaction(request) => {
|
|
sign_and_dispatch(client, miner, accounts, request, pass)
|
|
.map(|result| result
|
|
.map(RpcH256::from)
|
|
.map(ConfirmationResponse::SendTransaction)
|
|
)
|
|
},
|
|
ConfirmationPayload::SignTransaction(request) => {
|
|
sign_no_dispatch(client, miner, accounts, request, pass)
|
|
.map(|result| result
|
|
.map(RpcRichRawTransaction::from)
|
|
.map(ConfirmationResponse::SignTransaction)
|
|
)
|
|
},
|
|
ConfirmationPayload::Signature(address, mut data) => {
|
|
let mut message_data =
|
|
format!("\x19Ethereum Signed Message:\n{}", data.len())
|
|
.into_bytes();
|
|
message_data.append(&mut data);
|
|
signature(accounts, address, message_data.sha3(), pass)
|
|
.map(|result| result
|
|
.map(|rsv| {
|
|
let mut vrs = [0u8; 65];
|
|
let rsv = rsv.as_ref();
|
|
vrs[0] = rsv[64] + 27;
|
|
vrs[1..33].copy_from_slice(&rsv[0..32]);
|
|
vrs[33..65].copy_from_slice(&rsv[32..64]);
|
|
H520(vrs)
|
|
})
|
|
.map(RpcH520::from)
|
|
.map(ConfirmationResponse::Signature)
|
|
)
|
|
},
|
|
ConfirmationPayload::Decrypt(address, data) => {
|
|
decrypt(accounts, address, data, pass)
|
|
.map(|result| result
|
|
.map(RpcBytes)
|
|
.map(ConfirmationResponse::Decrypt)
|
|
)
|
|
},
|
|
}
|
|
}
|
|
|
|
fn signature(accounts: &AccountProvider, address: Address, hash: H256, password: SignWith) -> Result<WithToken<Signature>, Error> {
|
|
match password.clone() {
|
|
SignWith::Nothing => accounts.sign(address, None, hash).map(WithToken::No),
|
|
SignWith::Password(pass) => accounts.sign(address, Some(pass), hash).map(WithToken::No),
|
|
SignWith::Token(token) => accounts.sign_with_token(address, token, hash).map(Into::into),
|
|
}.map_err(|e| match password {
|
|
SignWith::Nothing => errors::from_signing_error(e),
|
|
_ => errors::from_password_error(e),
|
|
})
|
|
}
|
|
|
|
fn decrypt(accounts: &AccountProvider, address: Address, msg: Bytes, password: SignWith) -> Result<WithToken<Bytes>, Error> {
|
|
match password.clone() {
|
|
SignWith::Nothing => accounts.decrypt(address, None, &DEFAULT_MAC, &msg).map(WithToken::No),
|
|
SignWith::Password(pass) => accounts.decrypt(address, Some(pass), &DEFAULT_MAC, &msg).map(WithToken::No),
|
|
SignWith::Token(token) => accounts.decrypt_with_token(address, token, &DEFAULT_MAC, &msg).map(Into::into),
|
|
}.map_err(|e| match password {
|
|
SignWith::Nothing => errors::from_signing_error(e),
|
|
_ => errors::from_password_error(e),
|
|
})
|
|
}
|
|
|
|
pub fn dispatch_transaction<C, M>(client: &C, miner: &M, signed_transaction: PendingTransaction) -> Result<H256, Error>
|
|
where C: MiningBlockChainClient, M: MinerService {
|
|
let hash = signed_transaction.transaction.hash();
|
|
|
|
miner.import_own_transaction(client, signed_transaction)
|
|
.map_err(errors::from_transaction_error)
|
|
.map(|_| hash)
|
|
}
|
|
|
|
pub fn sign_no_dispatch<C, M>(client: &C, miner: &M, accounts: &AccountProvider, filled: FilledTransactionRequest, password: SignWith) -> Result<WithToken<SignedTransaction>, Error>
|
|
where C: MiningBlockChainClient, M: MinerService {
|
|
|
|
let network_id = client.signing_network_id();
|
|
let address = filled.from;
|
|
let signed_transaction = {
|
|
let t = Transaction {
|
|
nonce: filled.nonce
|
|
.or_else(|| miner
|
|
.last_nonce(&filled.from)
|
|
.map(|nonce| nonce + U256::one()))
|
|
.unwrap_or_else(|| client.latest_nonce(&filled.from)),
|
|
|
|
action: filled.to.map_or(Action::Create, Action::Call),
|
|
gas: filled.gas,
|
|
gas_price: filled.gas_price,
|
|
value: filled.value,
|
|
data: filled.data,
|
|
};
|
|
|
|
let hash = t.hash(network_id);
|
|
if accounts.is_hardware_address(address) {
|
|
let mut stream = rlp::RlpStream::new();
|
|
t.rlp_append_unsigned_transaction(&mut stream, network_id);
|
|
let signature = accounts.sign_with_hardware(address, &stream.as_raw())
|
|
.map_err(|e| {
|
|
debug!(target: "miner", "Error signing transaction with hardware wallet: {}", e);
|
|
errors::account("Error signing transaction with hardware wallet", e)
|
|
})?;
|
|
WithToken::No(SignedTransaction::new(t.with_signature(signature, network_id))
|
|
.map_err(|e| {
|
|
debug!(target: "miner", "Hardware wallet has produced invalid signature: {}", e);
|
|
errors::account("Invalid signature generated", e)
|
|
})?)
|
|
} else {
|
|
let signature = signature(accounts, address, hash, password)?;
|
|
signature.map(|sig| {
|
|
SignedTransaction::new(t.with_signature(sig, network_id))
|
|
.expect("Transaction was signed by AccountsProvider; it never produces invalid signatures; qed")
|
|
})
|
|
}
|
|
};
|
|
Ok(signed_transaction)
|
|
}
|
|
|
|
pub fn sign_and_dispatch<C, M>(client: &C, miner: &M, accounts: &AccountProvider, filled: FilledTransactionRequest, password: SignWith) -> Result<WithToken<H256>, Error>
|
|
where C: MiningBlockChainClient, M: MinerService
|
|
{
|
|
|
|
let network_id = client.signing_network_id();
|
|
let condition = filled.condition.clone();
|
|
let signed_transaction = sign_no_dispatch(client, miner, accounts, filled, password)?;
|
|
|
|
let (signed_transaction, token) = match signed_transaction {
|
|
WithToken::No(signed_transaction) => (signed_transaction, None),
|
|
WithToken::Yes(signed_transaction, token) => (signed_transaction, Some(token)),
|
|
};
|
|
|
|
trace!(target: "miner", "send_transaction: dispatching tx: {} for network ID {:?}", rlp::encode(&signed_transaction).to_vec().pretty(), network_id);
|
|
let pending_transaction = PendingTransaction::new(signed_transaction, condition.map(Into::into));
|
|
dispatch_transaction(&*client, &*miner, pending_transaction).map(|hash| {
|
|
match token {
|
|
Some(ref token) => WithToken::Yes(hash, token.clone()),
|
|
None => WithToken::No(hash),
|
|
}
|
|
})
|
|
}
|
|
|
|
pub fn fill_optional_fields<C, M>(request: TransactionRequest, default_sender: Address, client: &C, miner: &M) -> FilledTransactionRequest
|
|
where C: MiningBlockChainClient, M: MinerService
|
|
{
|
|
FilledTransactionRequest {
|
|
from: request.from.unwrap_or(default_sender),
|
|
used_default_from: request.from.is_none(),
|
|
to: request.to,
|
|
nonce: request.nonce,
|
|
gas_price: request.gas_price.unwrap_or_else(|| default_gas_price(client, miner)),
|
|
gas: request.gas.unwrap_or_else(|| miner.sensible_gas_limit()),
|
|
value: request.value.unwrap_or_else(|| 0.into()),
|
|
data: request.data.unwrap_or_else(Vec::new),
|
|
condition: request.condition,
|
|
}
|
|
}
|
|
|
|
pub fn default_gas_price<C, M>(client: &C, miner: &M) -> U256
|
|
where C: MiningBlockChainClient, M: MinerService
|
|
{
|
|
client.gas_price_median(100).unwrap_or_else(|| miner.sensible_gas_price())
|
|
}
|
|
|
|
pub fn from_rpc<C, M>(payload: RpcConfirmationPayload, default_account: Address, client: &C, miner: &M) -> ConfirmationPayload
|
|
where C: MiningBlockChainClient, M: MinerService {
|
|
|
|
match payload {
|
|
RpcConfirmationPayload::SendTransaction(request) => {
|
|
ConfirmationPayload::SendTransaction(fill_optional_fields(request.into(), default_account, client, miner))
|
|
},
|
|
RpcConfirmationPayload::SignTransaction(request) => {
|
|
ConfirmationPayload::SignTransaction(fill_optional_fields(request.into(), default_account, client, miner))
|
|
},
|
|
RpcConfirmationPayload::Decrypt(RpcDecryptRequest { address, msg }) => {
|
|
ConfirmationPayload::Decrypt(address.into(), msg.into())
|
|
},
|
|
RpcConfirmationPayload::Signature(RpcSignRequest { address, data }) => {
|
|
ConfirmationPayload::Signature(address.into(), data.into())
|
|
},
|
|
}
|
|
}
|