Initial In Instructions pallet and Serai client lib (#233)

* Initial work on an In Inherents pallet

* Add an event for when a batch is executed

* Add a dummy provider for InInstructions

* Add in-instructions to the node

* Add the Serai runtime API to the processor

* Move processor tests around

* Build a subxt Client around Serai

* Successfully get Batch events from Serai

Renamed processor/substrate to processor/serai.

* Much more robust InInstruction pallet

* Implement the workaround from https://github.com/paritytech/subxt/issues/602

* Initial prototype of processor generated InInstructions

* Correct PendingCoins data flow for InInstructions

* Minor lint to in-instructions

* Remove the global Serai connection for a partial re-impl

* Correct ID handling of the processor test

* Workaround the delay in the subscription

* Make an unwrap an if let Some, remove old comments

* Lint the processor toml

* Rebase and update

* Move substrate/in-instructions to substrate/in-instructions/pallet

* Start an in-instructions primitives lib

* Properly update processor to subxt 0.24

Also corrects failures from the rebase.

* in-instructions cargo update

* Implement IsFatalError

* is_inherent -> true

* Rename in-instructions crates and misc cleanup

* Update documentation

* cargo update

* Misc update fixes

* Replace height with block_number

* Update processor src to latest subxt

* Correct pipeline for InInstructions testing

* Remove runtime::AccountId for serai_primitives::NativeAddress

* Rewrite the in-instructions pallet

Complete with respect to the currently written docs.

Drops the custom serializer for just using SCALE.

Makes slight tweaks as relevant.

* Move instructions' InherentDataProvider to a client crate

* Correct doc gen

* Add serde to in-instructions-primitives

* Add in-instructions-primitives to pallet

* Heights -> BlockNumbers

* Get batch pub test loop working

* Update in instructions pallet terminology

Removes the ambiguous Coin for Update.

Removes pending/artificial latency for furture client work.

Also moves to using serai_primitives::Coin.

* Add a BlockNumber primitive

* Belated cargo fmt

* Further document why DifferentBatch isn't fatal

* Correct processor sleeps

* Remove metadata at compile time, add test framework for Serai nodes

* Remove manual RPC client

* Simplify update test

* Improve re-exporting behavior of serai-runtime

It now re-exports all pallets underneath it.

* Add a function to get storage values to the Serai RPC

* Update substrate/ to latest substrate

* Create a dedicated crate for the Serai RPC

* Remove unused dependencies in substrate/

* Remove unused dependencies in coins/

Out of scope for this branch, just minor and path of least resistance.

* Use substrate/serai/client for the Serai RPC lib

It's a bit out of place, since these client folders are intended for the node to
access pallets and so on. This is for end-users to access Serai as a whole.

In that sense, it made more sense as a top level folder, yet that also felt
out of place.

* Move InInstructions test to serai-client for now

* Final cleanup

* Update deny.toml

* Cargo.lock update from merging develop

* Update nightly

Attempt to work around the current CI failure, which is a Rust ICE.

We previously didn't upgrade due to clippy 10134, yet that's been reverted.

* clippy

* clippy

* fmt

* NativeAddress -> SeraiAddress

* Sec fix on non-provided updates and doc fixes

* Add Serai as a Coin

Necessary in order to swap to Serai.

* Add a BlockHash type, used for batch IDs

* Remove origin from InInstruction

Makes InInstructionTarget. Adds RefundableInInstruction with origin.

* Document storage items in in-instructions

* Rename serai/client/tests/serai.rs to updates.rs

It only tested publishing updates and their successful acceptance.

substrate/node/src/command_helper.rs

@@ -9,8 +9,11 @@ use sp_runtime::OpaqueExtrinsic;
 use sc_cli::Result;
 use sc_client_api::BlockBackend;
 
-use serai_runtime as runtime;
-use runtime::SystemCall;
+use serai_runtime::{
+  VERSION, BlockHashCount,
+  system::{self, Call as SystemCall},
+  transaction_payment, RuntimeCall, UncheckedExtrinsic, SignedPayload, Runtime,
+};
 
 use crate::service::FullClient;
 
@@ -45,35 +48,33 @@ impl frame_benchmarking_cli::ExtrinsicBuilder for RemarkBuilder {
 pub fn create_benchmark_extrinsic(
   client: &FullClient,
   sender: sp_core::sr25519::Pair,
-  call: runtime::RuntimeCall,
+  call: RuntimeCall,
   nonce: u32,
-) -> runtime::UncheckedExtrinsic {
+) -> UncheckedExtrinsic {
   let extra = (
-    frame_system::CheckNonZeroSender::<runtime::Runtime>::new(),
-    frame_system::CheckSpecVersion::<runtime::Runtime>::new(),
-    frame_system::CheckTxVersion::<runtime::Runtime>::new(),
-    frame_system::CheckGenesis::<runtime::Runtime>::new(),
-    frame_system::CheckEra::<runtime::Runtime>::from(sp_runtime::generic::Era::mortal(
-      u64::from(
-        runtime::BlockHashCount::get().checked_next_power_of_two().map(|c| c / 2).unwrap_or(2),
-      ),
+    system::CheckNonZeroSender::<Runtime>::new(),
+    system::CheckSpecVersion::<Runtime>::new(),
+    system::CheckTxVersion::<Runtime>::new(),
+    system::CheckGenesis::<Runtime>::new(),
+    system::CheckEra::<Runtime>::from(sp_runtime::generic::Era::mortal(
+      u64::from(BlockHashCount::get().checked_next_power_of_two().map(|c| c / 2).unwrap_or(2)),
       client.chain_info().best_number.into(),
     )),
-    frame_system::CheckNonce::<runtime::Runtime>::from(nonce),
-    frame_system::CheckWeight::<runtime::Runtime>::new(),
-    pallet_transaction_payment::ChargeTransactionPayment::<runtime::Runtime>::from(0),
+    system::CheckNonce::<Runtime>::from(nonce),
+    system::CheckWeight::<Runtime>::new(),
+    transaction_payment::ChargeTransactionPayment::<Runtime>::from(0),
   );
 
-  runtime::UncheckedExtrinsic::new_signed(
+  UncheckedExtrinsic::new_signed(
     call.clone(),
     sender.public(),
-    runtime::SignedPayload::from_raw(
+    SignedPayload::from_raw(
       call,
       extra.clone(),
       (
         (),
-        runtime::VERSION.spec_version,
-        runtime::VERSION.transaction_version,
+        VERSION.spec_version,
+        VERSION.transaction_version,
         client.block_hash(0).ok().flatten().unwrap(),
         client.chain_info().best_hash,
         (),