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/runtime/src/lib.rs

@@ -1,23 +1,46 @@
+#![cfg_attr(docsrs, feature(doc_cfg))]
+#![cfg_attr(docsrs, feature(doc_auto_cfg))]
 #![cfg_attr(not(feature = "std"), no_std)]
 #![recursion_limit = "256"]
 
 #[cfg(feature = "std")]
 include!(concat!(env!("OUT_DIR"), "/wasm_binary.rs"));
 
+// Re-export all components
+pub use serai_primitives as primitives;
+
+pub use frame_system as system;
+pub use frame_support as support;
+
+pub use pallet_balances as balances;
+pub use pallet_transaction_payment as transaction_payment;
+
+pub use pallet_assets as assets;
+pub use in_instructions_pallet as in_instructions;
+
+pub use validator_sets_pallet as validator_sets;
+
+pub use pallet_session as session;
+pub use pallet_tendermint as tendermint;
+
+// Actually used by the runtime
 use sp_core::OpaqueMetadata;
-pub use sp_core::sr25519::{Public, Signature};
+use sp_std::prelude::*;
+
+use sp_version::RuntimeVersion;
+#[cfg(feature = "std")]
+use sp_version::NativeVersion;
+
 use sp_runtime::{
   create_runtime_str, generic, impl_opaque_keys, KeyTypeId,
   traits::{Convert, OpaqueKeys, IdentityLookup, BlakeTwo256, Block as BlockT},
   transaction_validity::{TransactionSource, TransactionValidity},
   ApplyExtrinsicResult, Perbill,
 };
-use sp_std::prelude::*;
-#[cfg(feature = "std")]
-use sp_version::NativeVersion;
-use sp_version::RuntimeVersion;
 
-use frame_support::{
+use primitives::{PublicKey, Signature, SeraiAddress, Coin};
+
+use support::{
   traits::{ConstU8, ConstU32, ConstU64},
   weights::{
     constants::{RocksDbWeight, WEIGHT_REF_TIME_PER_SECOND},
@@ -25,22 +48,14 @@ use frame_support::{
   },
   parameter_types, construct_runtime,
 };
-pub use frame_system::Call as SystemCall;
 
-use serai_primitives::Coin;
+use transaction_payment::CurrencyAdapter;
 
-pub use pallet_balances::Call as BalancesCall;
-pub use pallet_assets::Call as AssetsCall;
-use pallet_transaction_payment::CurrencyAdapter;
-
-use pallet_session::PeriodicSessions;
+use session::PeriodicSessions;
 
 /// An index to a block.
 pub type BlockNumber = u32;
 
-/// Account ID type, equivalent to a public key
-pub type AccountId = Public;
-
 /// Balance of an account.
 // Distinct from serai-primitives Amount due to Substrate's requirements on this type.
 // If Amount could be dropped in here, it would be.
@@ -58,7 +73,7 @@ pub type Hash = sp_core::H256;
 pub mod opaque {
   use super::*;
 
-  pub use sp_runtime::OpaqueExtrinsic as UncheckedExtrinsic;
+  use sp_runtime::OpaqueExtrinsic as UncheckedExtrinsic;
 
   pub type Header = generic::Header<BlockNumber, BlakeTwo256>;
   pub type Block = generic::Block<Header, UncheckedExtrinsic>;
@@ -110,22 +125,22 @@ parameter_types! {
   pub const SS58Prefix: u8 = 42; // TODO: Remove for Bech32m
 
   // 1 MB block size limit
-  pub BlockLength: frame_system::limits::BlockLength =
-    frame_system::limits::BlockLength::max_with_normal_ratio(BLOCK_SIZE, NORMAL_DISPATCH_RATIO);
-  pub BlockWeights: frame_system::limits::BlockWeights =
-    frame_system::limits::BlockWeights::with_sensible_defaults(
+  pub BlockLength: system::limits::BlockLength =
+    system::limits::BlockLength::max_with_normal_ratio(BLOCK_SIZE, NORMAL_DISPATCH_RATIO);
+  pub BlockWeights: system::limits::BlockWeights =
+    system::limits::BlockWeights::with_sensible_defaults(
       Weight::from_ref_time(2u64 * WEIGHT_REF_TIME_PER_SECOND).set_proof_size(u64::MAX),
       NORMAL_DISPATCH_RATIO,
     );
 }
 
-impl frame_system::Config for Runtime {
-  type BaseCallFilter = frame_support::traits::Everything;
+impl system::Config for Runtime {
+  type BaseCallFilter = support::traits::Everything;
   type BlockWeights = BlockWeights;
   type BlockLength = BlockLength;
-  type AccountId = AccountId;
+  type AccountId = SeraiAddress;
   type RuntimeCall = RuntimeCall;
-  type Lookup = IdentityLookup<AccountId>;
+  type Lookup = IdentityLookup<SeraiAddress>;
   type Index = Index;
   type BlockNumber = BlockNumber;
   type Hash = Hash;
@@ -142,14 +157,14 @@ impl frame_system::Config for Runtime {
   type OnKilledAccount = ();
   type OnSetCode = ();
 
-  type AccountData = pallet_balances::AccountData<Balance>;
+  type AccountData = balances::AccountData<Balance>;
   type SystemWeightInfo = ();
   type SS58Prefix = SS58Prefix; // TODO: Remove for Bech32m
 
-  type MaxConsumers = frame_support::traits::ConstU32<16>;
+  type MaxConsumers = support::traits::ConstU32<16>;
 }
 
-impl pallet_balances::Config for Runtime {
+impl balances::Config for Runtime {
   type MaxLocks = ConstU32<50>;
   type MaxReserves = ();
   type ReserveIdentifier = [u8; 8];
@@ -158,10 +173,10 @@ impl pallet_balances::Config for Runtime {
   type DustRemoval = ();
   type ExistentialDeposit = ConstU64<500>;
   type AccountStore = System;
-  type WeightInfo = pallet_balances::weights::SubstrateWeight<Runtime>;
+  type WeightInfo = balances::weights::SubstrateWeight<Runtime>;
 }
 
-impl pallet_assets::Config for Runtime {
+impl assets::Config for Runtime {
   type RuntimeEvent = RuntimeEvent;
   type Balance = Balance;
   type Currency = Balances;
@@ -171,9 +186,8 @@ impl pallet_assets::Config for Runtime {
   type StringLimit = ConstU32<32>;
 
   // Don't allow anyone to create assets
-  type CreateOrigin =
-    frame_support::traits::AsEnsureOriginWithArg<frame_system::EnsureNever<AccountId>>;
-  type ForceOrigin = frame_system::EnsureRoot<AccountId>;
+  type CreateOrigin = support::traits::AsEnsureOriginWithArg<system::EnsureNever<SeraiAddress>>;
+  type ForceOrigin = system::EnsureRoot<SeraiAddress>;
 
   // Don't charge fees nor kill accounts
   type RemoveItemsLimit = ConstU32<0>;
@@ -188,12 +202,12 @@ impl pallet_assets::Config for Runtime {
   type Freezer = ();
   type Extra = ();
 
-  type WeightInfo = pallet_assets::weights::SubstrateWeight<Runtime>;
+  type WeightInfo = assets::weights::SubstrateWeight<Runtime>;
   #[cfg(feature = "runtime-benchmarks")]
   type BenchmarkHelper = ();
 }
 
-impl pallet_transaction_payment::Config for Runtime {
+impl transaction_payment::Config for Runtime {
   type RuntimeEvent = RuntimeEvent;
   type OnChargeTransaction = CurrencyAdapter<Balances, ()>;
   type OperationalFeeMultiplier = ConstU8<5>;
@@ -202,54 +216,57 @@ impl pallet_transaction_payment::Config for Runtime {
   type FeeMultiplierUpdate = ();
 }
 
+impl in_instructions::Config for Runtime {
+  type RuntimeEvent = RuntimeEvent;
+}
+
 const SESSION_LENGTH: BlockNumber = 5 * DAYS;
 type Sessions = PeriodicSessions<ConstU32<{ SESSION_LENGTH }>, ConstU32<{ SESSION_LENGTH }>>;
 
 pub struct IdentityValidatorIdOf;
-impl Convert<Public, Option<Public>> for IdentityValidatorIdOf {
-  fn convert(key: Public) -> Option<Public> {
+impl Convert<PublicKey, Option<PublicKey>> for IdentityValidatorIdOf {
+  fn convert(key: PublicKey) -> Option<PublicKey> {
     Some(key)
   }
 }
 
-impl validator_sets_pallet::Config for Runtime {
+impl validator_sets::Config for Runtime {
   type RuntimeEvent = RuntimeEvent;
 }
 
-impl pallet_session::Config for Runtime {
+impl session::Config for Runtime {
   type RuntimeEvent = RuntimeEvent;
-  type ValidatorId = AccountId;
+  type ValidatorId = SeraiAddress;
   type ValidatorIdOf = IdentityValidatorIdOf;
   type ShouldEndSession = Sessions;
   type NextSessionRotation = Sessions;
   type SessionManager = ();
   type SessionHandler = <SessionKeys as OpaqueKeys>::KeyTypeIdProviders;
   type Keys = SessionKeys;
-  type WeightInfo = pallet_session::weights::SubstrateWeight<Runtime>;
+  type WeightInfo = session::weights::SubstrateWeight<Runtime>;
 }
 
-impl pallet_tendermint::Config for Runtime {}
+impl tendermint::Config for Runtime {}
 
-pub type Address = AccountId;
 pub type Header = generic::Header<BlockNumber, BlakeTwo256>;
 pub type Block = generic::Block<Header, UncheckedExtrinsic>;
 pub type SignedExtra = (
-  frame_system::CheckNonZeroSender<Runtime>,
-  frame_system::CheckSpecVersion<Runtime>,
-  frame_system::CheckTxVersion<Runtime>,
-  frame_system::CheckGenesis<Runtime>,
-  frame_system::CheckEra<Runtime>,
-  frame_system::CheckNonce<Runtime>,
-  frame_system::CheckWeight<Runtime>,
-  pallet_transaction_payment::ChargeTransactionPayment<Runtime>,
+  system::CheckNonZeroSender<Runtime>,
+  system::CheckSpecVersion<Runtime>,
+  system::CheckTxVersion<Runtime>,
+  system::CheckGenesis<Runtime>,
+  system::CheckEra<Runtime>,
+  system::CheckNonce<Runtime>,
+  system::CheckWeight<Runtime>,
+  transaction_payment::ChargeTransactionPayment<Runtime>,
 );
 pub type UncheckedExtrinsic =
-  generic::UncheckedExtrinsic<Address, RuntimeCall, Signature, SignedExtra>;
+  generic::UncheckedExtrinsic<SeraiAddress, RuntimeCall, Signature, SignedExtra>;
 pub type SignedPayload = generic::SignedPayload<RuntimeCall, SignedExtra>;
 pub type Executive = frame_executive::Executive<
   Runtime,
   Block,
-  frame_system::ChainContext<Runtime>,
+  system::ChainContext<Runtime>,
   Runtime,
   AllPalletsWithSystem,
 >;
@@ -260,14 +277,18 @@ construct_runtime!(
     NodeBlock = Block,
     UncheckedExtrinsic = UncheckedExtrinsic
   {
-    System: frame_system,
-    Balances: pallet_balances,
-    Assets: pallet_assets,
-    TransactionPayment: pallet_transaction_payment,
+    System: system,
 
-    ValidatorSets: validator_sets_pallet,
-    Session: pallet_session,
-    Tendermint: pallet_tendermint,
+    Balances: balances,
+    TransactionPayment: transaction_payment,
+
+    Assets: assets,
+    InInstructions: in_instructions,
+
+    ValidatorSets: validator_sets,
+
+    Session: session,
+    Tendermint: tendermint,
   }
 );
 
@@ -279,8 +300,8 @@ extern crate frame_benchmarking;
 mod benches {
   define_benchmarks!(
     [frame_benchmarking, BaselineBench::<Runtime>]
-    [frame_system, SystemBench::<Runtime>]
-    [pallet_balances, Balances]
+    [system, SystemBench::<Runtime>]
+    [balances, Balances]
   );
 }
 
@@ -359,13 +380,13 @@ sp_api::impl_runtime_apis! {
       Tendermint::session()
     }
 
-    fn validators() -> Vec<Public> {
+    fn validators() -> Vec<PublicKey> {
       Session::validators()
     }
   }
 
-  impl frame_system_rpc_runtime_api::AccountNonceApi<Block, AccountId, Index> for Runtime {
-    fn account_nonce(account: AccountId) -> Index {
+  impl frame_system_rpc_runtime_api::AccountNonceApi<Block, SeraiAddress, Index> for Runtime {
+    fn account_nonce(account: SeraiAddress) -> Index {
       System::account_nonce(account)
     }
   }
@@ -380,10 +401,11 @@ sp_api::impl_runtime_apis! {
     ) -> pallet_transaction_payment_rpc_runtime_api::RuntimeDispatchInfo<Balance> {
       TransactionPayment::query_info(uxt, len)
     }
+
     fn query_fee_details(
       uxt: <Block as BlockT>::Extrinsic,
       len: u32,
-    ) -> pallet_transaction_payment::FeeDetails<Balance> {
+    ) -> transaction_payment::FeeDetails<Balance> {
       TransactionPayment::query_fee_details(uxt, len)
     }
   }