web3 0.1.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
112
113
114
115
116
117
118
119
120
121
122
123
124

use serde::{Serialize, Serializer};
use types::{Bytes, U64, U256, H256, H160, H2048};

/// The block type returned from RPC calls.
/// This is generic over a `TX` type.
#[derive(Debug, Clone, PartialEq, Deserialize)]
pub struct Block<TX> {
  /// Hash of the block
  pub hash: Option<H256>,
  /// Hash of the parent
  #[serde(rename="parentHash")]
  pub parent_hash: H256,
  /// Hash of the uncles
  #[serde(rename="sha3Uncles")]
  pub uncles_hash: H256,
  /// Miner/author's address.
  #[serde(rename="miner")]
  pub author: H160,
  /// State root hash
  #[serde(rename="stateRoot")]
  pub state_root: H256,
  /// Transactions root hash
  #[serde(rename="transactionsRoot")]
  pub transactions_root: H256,
  /// Transactions receipts root hash
  #[serde(rename="receiptsRoot")]
  pub receipts_root: H256,
  /// Block number. None if pending.
  pub number: Option<U64>,
  /// Gas Used
  #[serde(rename="gasUsed")]
  pub gas_used: U256,
  /// Gas Limit
  #[serde(rename="gasLimit")]
  pub gas_limit: U256,
  /// Extra data
  #[serde(rename="extraData")]
  pub extra_data: Bytes,
  /// Logs bloom
  #[serde(rename="logsBloom")]
  pub logs_bloom: H2048,
  /// Timestamp
  pub timestamp: U256,
  /// Difficulty
  pub difficulty: U256,
  /// Total difficulty
  #[serde(rename="totalDifficulty")]
  pub total_difficulty: U256,
  /// Seal fields
  #[serde(rename="sealFields")]
  pub seal_fields: Vec<Bytes>,
  /// Uncles' hashes
  pub uncles: Vec<H256>,
  /// Transactions
  pub transactions: Vec<TX>,
  /// Size in bytes
  pub size: Option<U256>,
}

/// Block Number
#[derive(Copy, Clone, Debug, PartialEq)]
pub enum BlockNumber {
  /// Latest block
  Latest,
  /// Earliest block (genesis)
  Earliest,
  /// Pending block (not yet part of the blockchain)
  Pending,
  /// Block by number from canon chain
  Number(u64),
}

impl From<u64> for BlockNumber {
  fn from(num: u64) -> Self {
    BlockNumber::Number(num)
  }
}

impl Serialize for BlockNumber {
  fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer {
    match *self {
      BlockNumber::Number(ref x) => serializer.serialize_str(&format!("0x{:x}", x)),
      BlockNumber::Latest => serializer.serialize_str("latest"),
      BlockNumber::Earliest => serializer.serialize_str("earliest"),
      BlockNumber::Pending => serializer.serialize_str("pending"),
    }
  }
}

/// Block Identifier
#[derive(Clone, Debug, PartialEq)]
pub enum BlockId {
  /// By Hash
  Hash(H256),
  /// By Number
  Number(BlockNumber),
}

impl Serialize for BlockId {
  fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where S: Serializer {
    match *self {
      BlockId::Hash(ref x) => serializer.serialize_str(&format!("0x{}", x)),
      BlockId::Number(ref num) => num.serialize(serializer),
    }
  }
}

impl From<u64> for BlockId {
  fn from(num: u64) -> Self {
    BlockNumber::Number(num).into()
  }
}

impl From<BlockNumber> for BlockId {
  fn from(num: BlockNumber) -> Self {
    BlockId::Number(num)
  }
}

impl From<H256> for BlockId {
  fn from(hash: H256) -> Self {
    BlockId::Hash(hash)
  }
}