web3 0.3.0

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

use std::mem;
use ethabi;
use futures::{Future, Async, 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"),
    }
  }
}