web3 0.3.1

Ethereum JSON-RPC client.
Documentation 
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
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116

use std::mem;
use ethabi;
use futures::{Async, Future, Poll};
use serde;

use contract;
use contract::tokens::Detokenize;
use helpers;
use rpc;
use types::Bytes;
use Error as ApiError;

#[derive(Debug)]
enum ResultType<T, F> {
    Decodable(helpers::CallResult<Bytes, F>, ethabi::Function),
    Simple(helpers::CallResult<T, F>),
    Constant(Result<T, contract::Error>),
    Done,
}

/// A standard function (RPC) call result.
/// Takes any type which is deserializable from JSON,
/// a function definition and a future which yields that type.
#[derive(Debug)]
pub struct CallResult<T, F> {
    inner: ResultType<T, F>,
}

impl<T, F> From<::helpers::CallResult<T, F>> for CallResult<T, F> {
    fn from(inner: ::helpers::CallResult<T, F>) -> Self {
        CallResult {
            inner: ResultType::Simple(inner),
        }
    }
}

impl<T, F, E> From<E> for CallResult<T, F>
where
    E: Into<contract::Error>,
{
    fn from(e: E) -> Self {
        CallResult {
            inner: ResultType::Constant(Err(e.into())),
        }
    }
}

/// Function-specific bytes-decoder future.
/// Takes any type which is deserializable from `Vec<ethabi::Token>`,
/// a function definition and a future which yields that type.
#[derive(Debug)]
pub struct QueryResult<T, F> {
    inner: ResultType<T, F>,
}

impl<T, F, E> From<E> for QueryResult<T, F>
where
    E: Into<contract::Error>,
{
    fn from(e: E) -> Self {
        QueryResult {
            inner: ResultType::Constant(Err(e.into())),
        }
    }
}

impl<T, F> QueryResult<T, F> {
    /// Create a new `QueryResult` wrapping the inner future.
    pub fn new(inner: helpers::CallResult<Bytes, F>, function: ethabi::Function) -> Self {
        QueryResult {
            inner: ResultType::Decodable(inner, function),
        }
    }
}

impl<T: Detokenize, F> Future for QueryResult<T, F>
where
    F: Future<Item = rpc::Value, Error = ApiError>,
{
    type Item = T;
    type Error = contract::Error;

    fn poll(&mut self) -> Poll<Self::Item, Self::Error> {
        if let ResultType::Decodable(ref mut inner, ref function) = self.inner {
            let bytes: Bytes = try_ready!(inner.poll());
            return Ok(Async::Ready(
                T::from_tokens(function.decode_output(&bytes.0)?)?,
            ));
        }

        match mem::replace(&mut self.inner, ResultType::Done) {
            ResultType::Constant(res) => res.map(Async::Ready),
            _ => panic!("Unsupported state"),
        }
    }
}

impl<T: serde::de::DeserializeOwned, F> Future for CallResult<T, F>
where
    F: Future<Item = rpc::Value, Error = ApiError>,
{
    type Item = T;
    type Error = contract::Error;

    fn poll(&mut self) -> Poll<Self::Item, Self::Error> {
        if let ResultType::Simple(ref mut inner) = self.inner {
            let hash: T = try_ready!(inner.poll());
            return Ok(Async::Ready(hash));
        }

        match mem::replace(&mut self.inner, ResultType::Done) {
            ResultType::Constant(res) => res.map(Async::Ready),
            _ => panic!("Unsupported state"),
        }
    }
}