Make API backwards compatible with CC (#1697)

* Rework how a runtime api calls into the runtime

Now we generate a default implementation for each api call that calls
a generated method `method_runtime_api_impl`. This newly generated
method is the one that will be implemented by the `impl_runtime_apis`
macro in the runtime for the client side.

* Support `changed_in` to change runtime api function signatures

* Update documentation

* Fixes tests

* Implement checking the api version with a predicate

* Make the implementation backwards compatible with CC

* Update wasm files after merge

* Check for wasm runtime differences by building master and current branch

* Update spec_version and wasm files

* Fixes

* Revert my changes

* Remove `patch.crates-io` from test-runtime

substrate/core/consensus/aura/src/lib.rs

@@ -34,7 +34,8 @@ use consensus_common::{
 };
 use consensus_common::import_queue::{Verifier, BasicQueue, SharedBlockImport, SharedJustificationImport};
 use client::ChainHead;
-use client::block_builder::api::BlockBuilder as BlockBuilderApi;
+use client::block_builder::api::{BlockBuilder as BlockBuilderApi, self as block_builder_api};
+use client::runtime_api::ApiExt;
 use consensus_common::{ImportBlock, BlockOrigin};
 use runtime_primitives::{generic, generic::BlockId, Justification};
 use runtime_primitives::traits::{
@@ -465,6 +466,50 @@ impl<C, E> AuraVerifier<C, E>
 			Ok(())
 		}
 	}
+
+	#[allow(deprecated)]
+	fn old_check_inherents<B: Block>(
+		&self,
+		block: B,
+		block_id: BlockId<B>,
+		inherent_data: InherentData,
+		timestamp_now: u64,
+	) -> Result<(), String>
+		where C: ProvideRuntimeApi, C::Api: BlockBuilderApi<B>
+	{
+		use block_builder_api::{OldInherentData, OldCheckInherentError};
+		const MAX_TIMESTAMP_DRIFT_SECS: u64 = 60;
+
+		let (timestamp, slot) = AuraSlotCompatible::extract_timestamp_and_slot(&inherent_data).map_err(|e| format!("{:?}", e))?;
+		let inherent_data = OldInherentData::new(timestamp, slot);
+
+		let inherent_res = self.client.runtime_api().check_inherents_before_version_2(
+			&block_id,
+			block,
+			inherent_data,
+		).map_err(|e| format!("{:?}", e))?;
+
+		match inherent_res {
+			Ok(()) => Ok(()),
+			Err(OldCheckInherentError::ValidAtTimestamp(timestamp)) => {
+				// halt import until timestamp is valid.
+				// reject when too far ahead.
+				if timestamp > timestamp_now + MAX_TIMESTAMP_DRIFT_SECS {
+					return Err("Rejecting block too far in future".into());
+				}
+
+				let diff = timestamp.saturating_sub(timestamp_now);
+				info!(
+					target: "aura",
+					"halting for block {} seconds in the future",
+					diff
+				);
+				thread::sleep(Duration::from_secs(diff));
+				Ok(())
+			},
+			Err(OldCheckInherentError::Other(e)) => Err(e.into())
+		}
+	}
 }
 
 /// No-op extra verification.
@@ -519,12 +564,25 @@ impl<B: Block, C, E> Verifier<B> for AuraVerifier<C, E> where
 					inherent_data.aura_replace_inherent_data(slot_num);
 					let block = B::new(pre_header.clone(), inner_body);
 
-					self.check_inherents(
-						block.clone(),
-						BlockId::Hash(parent_hash),
-						inherent_data,
-						timestamp_now,
-					)?;
+					if self.client
+						.runtime_api()
+						.has_api_with::<BlockBuilderApi<B>, _>(&BlockId::Hash(parent_hash), |v| v < 2)
+						.map_err(|e| format!("{:?}", e))?
+					{
+						self.old_check_inherents(
+							block.clone(),
+							BlockId::Hash(parent_hash),
+							inherent_data,
+							timestamp_now,
+						)?;
+					} else {
+						self.check_inherents(
+							block.clone(),
+							BlockId::Hash(parent_hash),
+							inherent_data,
+							timestamp_now,
+						)?;
+					}
 
 					let (_, inner_body) = block.deconstruct();
 					body = Some(inner_body);