Add RPC eth_chainId for querying the current blockchain chain ID

js/src/api/rpc/parity/parity.js

@@ -53,6 +53,11 @@ export default class Parity {
       );
   }
 
+  chainId () {
+    return this._transport
+      .execute('parity_chainId');
+  }
+
   chainStatus () {
     return this._transport
       .execute('parity_chainStatus')

js/src/jsonrpc/interfaces/parity.js

@@ -56,6 +56,16 @@ export default {
     }
   },
 
+  chainId: {
+    desc: 'Returns the current chain ID used for tranaction signing.',
+    params: [],
+    returns: {
+      type: Quantity,
+      desc: 'The current blockchain chain ID',
+      example: '0x1'
+    }
+  },
+
   chainStatus: {
     section: SECTION_NET,
     desc: 'Returns the information on warp sync blocks',

rpc/src/v1/impls/light/parity.rs

@@ -39,7 +39,7 @@ use v1::helpers::light_fetch::LightFetch;
 use v1::metadata::Metadata;
 use v1::traits::Parity;
 use v1::types::{
-	Bytes, U256, H160, H256, H512, CallRequest,
+	Bytes, U256, U64, H160, H256, H512, CallRequest,
 	Peers, Transaction, RpcSettings, Histogram,
 	TransactionStats, LocalTransactionStatus,
 	BlockNumber, ConsensusCapability, VersionInfo,
@@ -49,6 +49,7 @@ use v1::types::{
 
 /// Parity implementation for light client.
 pub struct ParityClient {
+	client: Arc<LightChainClient>,
 	light_dispatch: Arc<LightDispatcher>,
 	accounts: Arc<AccountProvider>,
 	logger: Arc<RotatingLogger>,
@@ -83,6 +84,7 @@ impl ParityClient {
 			dapps_address,
 			ws_address,
 			eip86_transition: client.eip86_transition(),
+			client: client,
 		}
 	}
 
@@ -320,6 +322,10 @@ impl Parity for ParityClient {
 		Err(errors::light_unimplemented(None))
 	}
 
+	fn chain_id(&self) -> Result<Option<U64>, Error> {
+		Ok(self.client.signing_chain_id().map(U64::from))
+	}
+
 	fn chain(&self) -> Result<String, Error> {
 		Ok(self.settings.chain.clone())
 	}

rpc/src/v1/impls/parity.rs

@@ -44,7 +44,7 @@ use v1::helpers::accounts::unwrap_provider;
 use v1::metadata::Metadata;
 use v1::traits::Parity;
 use v1::types::{
-	Bytes, U256, H160, H256, H512, CallRequest,
+	Bytes, U256, U64, H160, H256, H512, CallRequest,
 	Peers, Transaction, RpcSettings, Histogram,
 	TransactionStats, LocalTransactionStatus,
 	BlockNumber, ConsensusCapability, VersionInfo,
@@ -200,6 +200,10 @@ impl<C, M, U> Parity for ParityClient<C, M, U> where
 		Ok(self.settings.chain.clone())
 	}
 
+	fn chain_id(&self) -> Result<Option<U64>, Error> {
+		Ok(self.client.signing_chain_id().map(U64::from))
+	}
+
 	fn chain(&self) -> Result<String, Error> {
 		Ok(self.client.spec_name())
 	}

rpc/src/v1/tests/mocked/parity.rs

@@ -220,6 +220,17 @@ fn rpc_parity_extra_data() {
 	assert_eq!(io.handle_request_sync(request), Some(response.to_owned()));
 }
 
+#[test]
+fn rpc_parity_chain_id() {
+	let deps = Dependencies::new();
+	let io = deps.default_client();
+
+	let request = r#"{"jsonrpc": "2.0", "method": "parity_chainId", "params": [], "id": 1}"#;
+	let response = r#"{"jsonrpc":"2.0","result":null,"id":1}"#;
+
+	assert_eq!(io.handle_request_sync(request), Some(response.to_owned()));
+}
+
 #[test]
 fn rpc_parity_default_extra_data() {
 	use util::misc;

rpc/src/v1/traits/parity.rs

@@ -24,7 +24,7 @@ use futures::BoxFuture;
 
 use node_health::Health;
 use v1::types::{
-	H160, H256, H512, U256, Bytes, CallRequest,
+	H160, H256, H512, U256, U64, Bytes, CallRequest,
 	Peers, Transaction, RpcSettings, Histogram,
 	TransactionStats, LocalTransactionStatus,
 	BlockNumber, ConsensusCapability, VersionInfo,
@@ -172,6 +172,12 @@ build_rpc_trait! {
 		#[rpc(name = "parity_mode")]
 		fn mode(&self) -> Result<String, Error>;
 
+		/// Returns the chain ID used for transaction signing at the
+		/// current best block. An empty string is returned if not
+		/// available.
+		#[rpc(name = "parity_chainId")]
+		fn chain_id(&self) -> Result<Option<U64>, Error>;
+
 		/// Get the chain name. Returns one of: "foundation", "kovan", &c. of a filename.
 		#[rpc(name = "parity_chain")]
 		fn chain(&self) -> Result<String, Error>;

rpc/src/v1/types/mod.rs

@@ -76,7 +76,7 @@ pub use self::trace_filter::TraceFilter;
 pub use self::transaction::{Transaction, RichRawTransaction, LocalTransactionStatus};
 pub use self::transaction_request::TransactionRequest;
 pub use self::transaction_condition::TransactionCondition;
-pub use self::uint::{U128, U256};
+pub use self::uint::{U128, U256, U64};
 pub use self::work::Work;
 
 // TODO [ToDr] Refactor to a proper type Vec of enums?

rpc/src/v1/types/transaction.rs

@@ -20,7 +20,7 @@ use ethcore::miner;
 use ethcore::{contract_address, CreateContractAddress};
 use ethcore::transaction::{LocalizedTransaction, Action, PendingTransaction, SignedTransaction};
 use v1::helpers::errors;
-use v1::types::{Bytes, H160, H256, U256, H512, TransactionCondition};
+use v1::types::{Bytes, H160, H256, U256, H512, U64, TransactionCondition};
 
 /// Transaction
 #[derive(Debug, Default, Clone, PartialEq, Serialize)]
@@ -60,7 +60,7 @@ pub struct Transaction {
 	pub public_key: Option<H512>,
 	/// The network id of the transaction, if any.
 	#[serde(rename="chainId")]
-	pub chain_id: Option<u64>,
+	pub chain_id: Option<U64>,
 	/// The standardised V field of the signature (0 or 1).
 	#[serde(rename="standardV")]
 	pub standard_v: U256,
@@ -196,7 +196,7 @@ impl Transaction {
 			},
 			raw: ::rlp::encode(&t.signed).into_vec().into(),
 			public_key: t.recover_public().ok().map(Into::into),
-			chain_id: t.chain_id(),
+			chain_id: t.chain_id().map(U64::from),
 			standard_v: t.standard_v().into(),
 			v: t.original_v().into(),
 			r: signature.r().into(),
@@ -230,7 +230,7 @@ impl Transaction {
 			},
 			raw: ::rlp::encode(&t).into_vec().into(),
 			public_key: t.public_key().map(Into::into),
-			chain_id: t.chain_id(),
+			chain_id: t.chain_id().map(U64::from),
 			standard_v: t.standard_v().into(),
 			v: t.original_v().into(),
 			r: signature.r().into(),

rpc/src/v1/types/uint.rs

@@ -59,12 +59,6 @@ macro_rules! impl_uint {
 			}
 		}
 
-		impl serde::Serialize for $name {
-			fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where S: serde::Serializer {
-				serializer.serialize_str(&format!("0x{}", self.0.to_hex()))
-			}
-		}
-
 		impl<'a> serde::Deserialize<'a> for $name {
 			fn deserialize<D>(deserializer: D) -> Result<$name, D::Error>
 			where D: serde::Deserializer<'a> {
@@ -104,7 +98,25 @@ macro_rules! impl_uint {
 
 impl_uint!(U128, EthU128, 2);
 impl_uint!(U256, EthU256, 4);
+impl_uint!(U64, u64, 1);
+
+impl serde::Serialize for U128 {
+	fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where S: serde::Serializer {
+		serializer.serialize_str(&format!("0x{}", self.0.to_hex()))
+	}
+}
 
+impl serde::Serialize for U256 {
+	fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where S: serde::Serializer {
+		serializer.serialize_str(&format!("0x{}", self.0.to_hex()))
+	}
+}
+
+impl serde::Serialize for U64 {
+	fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where S: serde::Serializer {
+		serializer.serialize_str(&format!("0x{:x}", self.0))
+	}
+}
 
 #[cfg(test)]
 mod tests {