1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76

// Copyright 2015-2020 Parity Technologies (UK) Ltd.
// This file is part of OpenEthereum.

// OpenEthereum 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.

// OpenEthereum 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 OpenEthereum.  If not, see <http://www.gnu.org/licenses/>.

use client::{Rpc, RpcError};
use ethereum_types::U256;
use futures::Canceled;
use rpc::signer::{ConfirmationRequest, TransactionCondition, TransactionModification};
use serde;
use serde_json::{to_value, Value as JsonValue};
use std::path::PathBuf;
use BoxFuture;

pub struct SignerRpc {
    rpc: Rpc,
}

impl SignerRpc {
    pub fn new(url: &str, authfile: &PathBuf) -> Result<Self, RpcError> {
        Ok(SignerRpc {
            rpc: Rpc::new(&url, authfile)?,
        })
    }

    pub fn requests_to_confirm(
        &mut self,
    ) -> BoxFuture<Result<Vec<ConfirmationRequest>, RpcError>, Canceled> {
        self.rpc.request("signer_requestsToConfirm", vec![])
    }

    pub fn confirm_request(
        &mut self,
        id: U256,
        new_gas: Option<U256>,
        new_gas_price: Option<U256>,
        new_condition: Option<Option<TransactionCondition>>,
        pwd: &str,
    ) -> BoxFuture<Result<U256, RpcError>, Canceled> {
        self.rpc.request(
            "signer_confirmRequest",
            vec![
                Self::to_value(&format!("{:#x}", id)),
                Self::to_value(&TransactionModification {
                    sender: None,
                    gas_price: new_gas_price,
                    gas: new_gas,
                    condition: new_condition,
                }),
                Self::to_value(&pwd),
            ],
        )
    }

    pub fn reject_request(&mut self, id: U256) -> BoxFuture<Result<bool, RpcError>, Canceled> {
        self.rpc.request(
            "signer_rejectRequest",
            vec![JsonValue::String(format!("{:#x}", id))],
        )
    }

    fn to_value<T: serde::Serialize>(v: &T) -> JsonValue {
        to_value(v).expect("Our types are always serializable; qed")
    }
}