Merge branch 'develop' into HEAD

substrate/abi/Cargo.toml

@@ -16,28 +16,50 @@ rustdoc-args = ["--cfg", "docsrs"]
 workspace = true
 
 [dependencies]
-scale = { package = "parity-scale-codec", version = "3", features = ["derive"] }
-scale-info = { version = "2", features = ["derive"] }
+scale = { package = "parity-scale-codec", version = "3", default-features = false, features = ["derive"] }
+scale-info = { version = "2", default-features = false, features = ["derive"] }
 
-borsh = { version = "1", features = ["derive", "de_strict_order"], optional = true }
-serde = { version = "1", features = ["derive", "alloc"], optional = true }
+borsh = { version = "1", default-features = false, features = ["derive", "de_strict_order"], optional = true }
+serde = { version = "1", default-features = false, features = ["derive", "alloc"], optional = true }
 
-sp-core = { git = "https://github.com/serai-dex/substrate" }
-sp-runtime = { git = "https://github.com/serai-dex/substrate" }
+sp-core = { git = "https://github.com/serai-dex/substrate", default-features = false }
+sp-runtime = { git = "https://github.com/serai-dex/substrate", default-features = false }
 
-sp-consensus-babe = { git = "https://github.com/serai-dex/substrate" }
-sp-consensus-grandpa = { git = "https://github.com/serai-dex/substrate" }
+sp-consensus-babe = { git = "https://github.com/serai-dex/substrate", default-features = false }
+sp-consensus-grandpa = { git = "https://github.com/serai-dex/substrate", default-features = false }
 
-serai-primitives = { path = "../primitives", version = "0.1" }
-serai-coins-primitives = { path = "../coins/primitives", version = "0.1" }
-serai-validator-sets-primitives = { path = "../validator-sets/primitives", version = "0.1" }
+frame-support = { git = "https://github.com/serai-dex/substrate", default-features = false }
+
+serai-primitives = { path = "../primitives", version = "0.1", default-features = false }
+serai-coins-primitives = { path = "../coins/primitives", version = "0.1", default-features = false }
+serai-validator-sets-primitives = { path = "../validator-sets/primitives", version = "0.1", default-features = false }
 serai-genesis-liquidity-primitives = { path = "../genesis-liquidity/primitives", version = "0.1" }
-serai-in-instructions-primitives = { path = "../in-instructions/primitives", version = "0.1" }
-serai-signals-primitives = { path = "../signals/primitives", version = "0.1" }
-
-frame-support = { git = "https://github.com/serai-dex/substrate" }
+serai-in-instructions-primitives = { path = "../in-instructions/primitives", version = "0.1", default-features = false }
+serai-signals-primitives = { path = "../signals/primitives", version = "0.1", default-features = false }
 
 [features]
+std = [
+  "scale/std",
+  "scale-info/std",
+
+  "borsh?/std",
+  "serde?/std",
+
+  "sp-core/std",
+  "sp-runtime/std",
+
+  "sp-consensus-babe/std",
+  "sp-consensus-grandpa/std",
+
+  "frame-support/std",
+
+  "serai-primitives/std",
+  "serai-coins-primitives/std",
+  "serai-validator-sets-primitives/std",
+  "serai-genesis-liquidity-primitives/std",
+  "serai-in-instructions-primitives/std",
+  "serai-signals-primitives/std",
+]
 borsh = [
   "dep:borsh",
   "serai-primitives/borsh",
@@ -56,3 +78,4 @@ serde = [
   "serai-in-instructions-primitives/serde",
   "serai-signals-primitives/serde",
 ]
+default = ["std"]

substrate/abi/src/babe.rs

@@ -4,7 +4,7 @@ use serai_primitives::{Header, SeraiAddress};
 
 #[derive(Clone, PartialEq, Eq, Debug, scale::Encode, scale::Decode, scale_info::TypeInfo)]
 pub struct ReportEquivocation {
-  pub equivocation_proof: Box<EquivocationProof<Header>>,
+  pub equivocation_proof: alloc::boxed::Box<EquivocationProof<Header>>,
   pub key_owner_proof: SeraiAddress,
 }
 

substrate/abi/src/coins.rs

@@ -5,7 +5,8 @@ use primitives::OutInstructionWithBalance;
 
 #[derive(Clone, PartialEq, Eq, Debug, scale::Encode, scale::Decode, scale_info::TypeInfo)]
 #[cfg_attr(feature = "borsh", derive(borsh::BorshSerialize, borsh::BorshDeserialize))]
-#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
+#[cfg_attr(feature = "serde", derive(serde::Serialize))]
+#[cfg_attr(all(feature = "std", feature = "serde"), derive(serde::Deserialize))]
 pub enum Call {
   transfer { to: SeraiAddress, balance: Balance },
   burn { balance: Balance },
@@ -14,7 +15,17 @@ pub enum Call {
 
 #[derive(Clone, PartialEq, Eq, Debug, scale::Encode, scale::Decode, scale_info::TypeInfo)]
 #[cfg_attr(feature = "borsh", derive(borsh::BorshSerialize, borsh::BorshDeserialize))]
-#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
+#[cfg_attr(feature = "serde", derive(serde::Serialize))]
+#[cfg_attr(all(feature = "std", feature = "serde"), derive(serde::Deserialize))]
+pub enum LiquidityTokensCall {
+  transfer { to: SeraiAddress, balance: Balance },
+  burn { balance: Balance },
+}
+
+#[derive(Clone, PartialEq, Eq, Debug, scale::Encode, scale::Decode, scale_info::TypeInfo)]
+#[cfg_attr(feature = "borsh", derive(borsh::BorshSerialize, borsh::BorshDeserialize))]
+#[cfg_attr(feature = "serde", derive(serde::Serialize))]
+#[cfg_attr(all(feature = "std", feature = "serde"), derive(serde::Deserialize))]
 pub enum Event {
   Mint { to: SeraiAddress, balance: Balance },
   Burn { from: SeraiAddress, balance: Balance },

substrate/abi/src/dex.rs

@@ -6,7 +6,8 @@ type PoolId = Coin;
 type MaxSwapPathLength = sp_core::ConstU32<3>;
 
 #[derive(Clone, PartialEq, Eq, Debug, scale::Encode, scale::Decode, scale_info::TypeInfo)]
-#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
+#[cfg_attr(feature = "serde", derive(serde::Serialize))]
+#[cfg_attr(all(feature = "std", feature = "serde"), derive(serde::Deserialize))]
 pub enum Call {
   add_liquidity {
     coin: Coin,
@@ -38,7 +39,8 @@ pub enum Call {
 }
 
 #[derive(Clone, PartialEq, Eq, Debug, scale::Encode, scale::Decode, scale_info::TypeInfo)]
-#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
+#[cfg_attr(feature = "serde", derive(serde::Serialize))]
+#[cfg_attr(all(feature = "std", feature = "serde"), derive(serde::Deserialize))]
 pub enum Event {
   PoolCreated {
     pool_id: PoolId,

substrate/abi/src/grandpa.rs

@@ -4,7 +4,7 @@ use serai_primitives::{BlockNumber, SeraiAddress};
 
 #[derive(Clone, PartialEq, Eq, Debug, scale::Encode, scale::Decode, scale_info::TypeInfo)]
 pub struct ReportEquivocation {
-  pub equivocation_proof: Box<EquivocationProof<[u8; 32], BlockNumber>>,
+  pub equivocation_proof: alloc::boxed::Box<EquivocationProof<[u8; 32], BlockNumber>>,
   pub key_owner_proof: SeraiAddress,
 }
 
@@ -15,10 +15,10 @@ pub enum Call {
 }
 
 #[derive(Clone, PartialEq, Eq, Debug, scale::Encode, scale::Decode, scale_info::TypeInfo)]
-#[cfg_attr(feature = "borsh", derive(borsh::BorshSerialize, borsh::BorshDeserialize))]
-#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
+#[cfg_attr(feature = "serde", derive(serde::Serialize))]
+#[cfg_attr(all(feature = "std", feature = "serde"), derive(serde::Deserialize))]
 pub enum Event {
-  NewAuthorities { authority_set: Vec<(SeraiAddress, u64)> },
+  NewAuthorities { authority_set: alloc::vec::Vec<(SeraiAddress, u64)> },
   // TODO: Remove these
   Paused,
   Resumed,

substrate/abi/src/in_instructions.rs

@@ -5,14 +5,16 @@ use primitives::SignedBatch;
 
 #[derive(Clone, PartialEq, Eq, Debug, scale::Encode, scale::Decode, scale_info::TypeInfo)]
 #[cfg_attr(feature = "borsh", derive(borsh::BorshSerialize, borsh::BorshDeserialize))]
-#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
+#[cfg_attr(feature = "serde", derive(serde::Serialize))]
+#[cfg_attr(all(feature = "std", feature = "serde"), derive(serde::Deserialize))]
 pub enum Call {
   execute_batch { batch: SignedBatch },
 }
 
 #[derive(Clone, PartialEq, Eq, Debug, scale::Encode, scale::Decode, scale_info::TypeInfo)]
 #[cfg_attr(feature = "borsh", derive(borsh::BorshSerialize, borsh::BorshDeserialize))]
-#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
+#[cfg_attr(feature = "serde", derive(serde::Serialize))]
+#[cfg_attr(all(feature = "std", feature = "serde"), derive(serde::Deserialize))]
 pub enum Event {
   Batch { network: NetworkId, id: u32, block: BlockHash, instructions_hash: [u8; 32] },
   InstructionFailure { network: NetworkId, id: u32, index: u32 },

substrate/abi/src/lib.rs

@@ -1,5 +1,12 @@
+#![cfg_attr(docsrs, feature(doc_cfg))]
+#![cfg_attr(docsrs, feature(doc_auto_cfg))]
+#![cfg_attr(not(feature = "std"), no_std)]
 #![allow(non_camel_case_types)]
 
+extern crate alloc;
+
+pub use serai_primitives as primitives;
+
 pub mod system;
 
 pub mod timestamp;
@@ -16,15 +23,13 @@ pub mod genesis_liquidity;
 pub mod babe;
 pub mod grandpa;
 
-pub use serai_primitives as primitives;
+pub mod tx;
 
 #[derive(Clone, PartialEq, Eq, Debug, scale::Encode, scale::Decode, scale_info::TypeInfo)]
 pub enum Call {
-  System,
   Timestamp(timestamp::Call),
-  TransactionPayment,
   Coins(coins::Call),
-  LiquidityTokens(coins::Call),
+  LiquidityTokens(coins::LiquidityTokensCall),
   Dex(dex::Call),
   GenesisLiquidity(genesis_liquidity::Call),
   ValidatorSets(validator_sets::Call),
@@ -57,16 +62,20 @@ pub enum Event {
 }
 
 #[derive(Clone, Copy, PartialEq, Eq, Debug, scale::Encode, scale::Decode, scale_info::TypeInfo)]
-#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
+#[cfg_attr(feature = "serde", derive(serde::Serialize))]
+#[cfg_attr(all(feature = "std", feature = "serde"), derive(serde::Deserialize))]
 pub struct Extra {
   pub era: sp_runtime::generic::Era,
-  pub nonce: scale::Compact<u32>,
-  pub tip: scale::Compact<u64>,
+  #[codec(compact)]
+  pub nonce: u32,
+  #[codec(compact)]
+  pub tip: u64,
 }
 
 #[derive(Clone, PartialEq, Eq, Debug, scale::Encode, scale::Decode, scale_info::TypeInfo)]
 #[cfg_attr(feature = "borsh", derive(borsh::BorshSerialize, borsh::BorshDeserialize))]
-#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
+#[cfg_attr(feature = "serde", derive(serde::Serialize))]
+#[cfg_attr(all(feature = "std", feature = "serde"), derive(serde::Deserialize))]
 pub struct SignedPayloadExtra {
   pub spec_version: u32,
   pub tx_version: u32,
@@ -74,4 +83,4 @@ pub struct SignedPayloadExtra {
   pub mortality_checkpoint: [u8; 32],
 }
 
-pub type Transaction = primitives::Transaction<Call, Extra>;
+pub type Transaction = tx::Transaction<Call, Extra>;

substrate/abi/src/signals.rs

@@ -7,7 +7,8 @@ use primitives::SignalId;
 
 #[derive(Clone, PartialEq, Eq, Debug, scale::Encode, scale::Decode, scale_info::TypeInfo)]
 #[cfg_attr(feature = "borsh", derive(borsh::BorshSerialize, borsh::BorshDeserialize))]
-#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
+#[cfg_attr(feature = "serde", derive(serde::Serialize))]
+#[cfg_attr(all(feature = "std", feature = "serde"), derive(serde::Deserialize))]
 pub enum Call {
   register_retirement_signal { in_favor_of: [u8; 32] },
   revoke_retirement_signal { retirement_signal_id: [u8; 32] },
@@ -18,7 +19,8 @@ pub enum Call {
 
 #[derive(Clone, PartialEq, Eq, Debug, scale::Encode, scale::Decode, scale_info::TypeInfo)]
 #[cfg_attr(feature = "borsh", derive(borsh::BorshSerialize, borsh::BorshDeserialize))]
-#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
+#[cfg_attr(feature = "serde", derive(serde::Serialize))]
+#[cfg_attr(all(feature = "std", feature = "serde"), derive(serde::Deserialize))]
 pub enum Event {
   RetirementSignalRegistered {
     signal_id: [u8; 32],

substrate/abi/src/system.rs

@@ -3,7 +3,6 @@ use frame_support::dispatch::{DispatchInfo, DispatchError};
 use serai_primitives::SeraiAddress;
 
 #[derive(Clone, PartialEq, Eq, Debug, scale::Encode, scale::Decode, scale_info::TypeInfo)]
-#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub enum Event {
   ExtrinsicSuccess { dispatch_info: DispatchInfo },
   ExtrinsicFailed { dispatch_error: DispatchError, dispatch_info: DispatchInfo },

substrate/abi/src/timestamp.rs

@@ -1,5 +1,9 @@
 #[derive(Clone, PartialEq, Eq, Debug, scale::Encode, scale::Decode, scale_info::TypeInfo)]
-#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
+#[cfg_attr(feature = "serde", derive(serde::Serialize))]
+#[cfg_attr(all(feature = "std", feature = "serde"), derive(serde::Deserialize))]
 pub enum Call {
-  set { now: scale::Compact<u64> },
+  set {
+    #[codec(compact)]
+    now: u64,
+  },
 }

substrate/abi/src/tx.rs

@@ -0,0 +1,183 @@
+use scale::Encode;
+
+use sp_core::sr25519::{Public, Signature};
+use sp_runtime::traits::Verify;
+
+use serai_primitives::SeraiAddress;
+
+use frame_support::dispatch::GetDispatchInfo;
+
+pub trait TransactionMember:
+  Clone + PartialEq + Eq + core::fmt::Debug + scale::Encode + scale::Decode + scale_info::TypeInfo
+{
+}
+impl<
+    T: Clone
+      + PartialEq
+      + Eq
+      + core::fmt::Debug
+      + scale::Encode
+      + scale::Decode
+      + scale_info::TypeInfo,
+  > TransactionMember for T
+{
+}
+
+type TransactionEncodeAs<'a, Extra> =
+  (&'a crate::Call, &'a Option<(SeraiAddress, Signature, Extra)>);
+type TransactionDecodeAs<Extra> = (crate::Call, Option<(SeraiAddress, Signature, Extra)>);
+
+// We use our own Transaction struct, over UncheckedExtrinsic, for more control, a bit more
+// simplicity, and in order to be immune to https://github.com/paritytech/polkadot-sdk/issues/2947
+#[allow(private_bounds)]
+#[derive(Clone, PartialEq, Eq, Debug)]
+pub struct Transaction<
+  Call: 'static + TransactionMember + From<crate::Call>,
+  Extra: 'static + TransactionMember,
+> {
+  call: crate::Call,
+  mapped_call: Call,
+  signature: Option<(SeraiAddress, Signature, Extra)>,
+}
+
+impl<Call: 'static + TransactionMember + From<crate::Call>, Extra: 'static + TransactionMember>
+  Transaction<Call, Extra>
+{
+  pub fn new(call: crate::Call, signature: Option<(SeraiAddress, Signature, Extra)>) -> Self {
+    Self { call: call.clone(), mapped_call: call.into(), signature }
+  }
+
+  pub fn call(&self) -> &crate::Call {
+    &self.call
+  }
+}
+
+impl<Call: 'static + TransactionMember + From<crate::Call>, Extra: 'static + TransactionMember>
+  scale::Encode for Transaction<Call, Extra>
+{
+  fn using_encoded<R, F: FnOnce(&[u8]) -> R>(&self, f: F) -> R {
+    let tx: TransactionEncodeAs<Extra> = (&self.call, &self.signature);
+    tx.using_encoded(f)
+  }
+}
+impl<Call: 'static + TransactionMember + From<crate::Call>, Extra: 'static + TransactionMember>
+  scale::Decode for Transaction<Call, Extra>
+{
+  fn decode<I: scale::Input>(input: &mut I) -> Result<Self, scale::Error> {
+    let (call, signature) = TransactionDecodeAs::decode(input)?;
+    let mapped_call = Call::from(call.clone());
+    Ok(Self { call, mapped_call, signature })
+  }
+}
+impl<Call: 'static + TransactionMember + From<crate::Call>, Extra: 'static + TransactionMember>
+  scale_info::TypeInfo for Transaction<Call, Extra>
+{
+  type Identity = TransactionDecodeAs<Extra>;
+
+  // Define the type info as the info of the type equivalent to what we encode as
+  fn type_info() -> scale_info::Type {
+    TransactionDecodeAs::<Extra>::type_info()
+  }
+}
+
+#[cfg(feature = "serde")]
+mod _serde {
+  use scale::Encode;
+  use serde::{ser::*, de::*};
+  use super::*;
+  impl<Call: 'static + TransactionMember + From<crate::Call>, Extra: 'static + TransactionMember>
+    Serialize for Transaction<Call, Extra>
+  {
+    fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
+      let encoded = self.encode();
+      serializer.serialize_bytes(&encoded)
+    }
+  }
+  #[cfg(feature = "std")]
+  impl<
+      'a,
+      Call: 'static + TransactionMember + From<crate::Call>,
+      Extra: 'static + TransactionMember,
+    > Deserialize<'a> for Transaction<Call, Extra>
+  {
+    fn deserialize<D: Deserializer<'a>>(de: D) -> Result<Self, D::Error> {
+      let bytes = sp_core::bytes::deserialize(de)?;
+      <Self as scale::Decode>::decode(&mut &bytes[..])
+        .map_err(|e| serde::de::Error::custom(format!("invalid transaction: {e}")))
+    }
+  }
+}
+
+impl<
+    Call: 'static + TransactionMember + From<crate::Call> + TryInto<crate::Call>,
+    Extra: 'static + TransactionMember,
+  > sp_runtime::traits::Extrinsic for Transaction<Call, Extra>
+{
+  type Call = Call;
+  type SignaturePayload = (SeraiAddress, Signature, Extra);
+  fn is_signed(&self) -> Option<bool> {
+    Some(self.signature.is_some())
+  }
+  fn new(call: Call, signature: Option<Self::SignaturePayload>) -> Option<Self> {
+    Some(Self { call: call.clone().try_into().ok()?, mapped_call: call, signature })
+  }
+}
+
+impl<
+    Call: 'static + TransactionMember + From<crate::Call> + TryInto<crate::Call>,
+    Extra: 'static + TransactionMember,
+  > frame_support::traits::ExtrinsicCall for Transaction<Call, Extra>
+{
+  fn call(&self) -> &Call {
+    &self.mapped_call
+  }
+}
+
+impl<
+    Call: 'static + TransactionMember + From<crate::Call>,
+    Extra: 'static + TransactionMember + sp_runtime::traits::SignedExtension,
+  > sp_runtime::traits::ExtrinsicMetadata for Transaction<Call, Extra>
+{
+  type SignedExtensions = Extra;
+
+  const VERSION: u8 = 0;
+}
+
+impl<
+    Call: 'static + TransactionMember + From<crate::Call> + GetDispatchInfo,
+    Extra: 'static + TransactionMember,
+  > GetDispatchInfo for Transaction<Call, Extra>
+{
+  fn get_dispatch_info(&self) -> frame_support::dispatch::DispatchInfo {
+    self.mapped_call.get_dispatch_info()
+  }
+}
+
+impl<
+    Call: 'static + TransactionMember + From<crate::Call>,
+    Extra: 'static + TransactionMember + sp_runtime::traits::SignedExtension,
+  > sp_runtime::traits::BlindCheckable for Transaction<Call, Extra>
+{
+  type Checked = sp_runtime::generic::CheckedExtrinsic<Public, Call, Extra>;
+
+  fn check(
+    self,
+  ) -> Result<Self::Checked, sp_runtime::transaction_validity::TransactionValidityError> {
+    Ok(match self.signature {
+      Some((signer, signature, extra)) => {
+        if !signature.verify(
+          (&self.call, &extra, extra.additional_signed()?).encode().as_slice(),
+          &signer.into(),
+        ) {
+          Err(sp_runtime::transaction_validity::InvalidTransaction::BadProof)?
+        }
+
+        sp_runtime::generic::CheckedExtrinsic {
+          signed: Some((signer.into(), extra)),
+          function: self.mapped_call,
+        }
+      }
+      None => sp_runtime::generic::CheckedExtrinsic { signed: None, function: self.mapped_call },
+    })
+  }
+}

substrate/abi/src/validator_sets.rs

@@ -1,4 +1,4 @@
-use sp_core::{ConstU32, bounded_vec::BoundedVec};
+use sp_core::{ConstU32, bounded::BoundedVec};
 
 pub use serai_validator_sets_primitives as primitives;
 
@@ -6,11 +6,12 @@ use serai_primitives::*;
 use serai_validator_sets_primitives::*;
 
 #[derive(Clone, PartialEq, Eq, Debug, scale::Encode, scale::Decode, scale_info::TypeInfo)]
-#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
+#[cfg_attr(feature = "serde", derive(serde::Serialize))]
+#[cfg_attr(all(feature = "std", feature = "serde"), derive(serde::Deserialize))]
 pub enum Call {
   set_keys {
     network: NetworkId,
-    removed_participants: Vec<SeraiAddress>,
+    removed_participants: BoundedVec<SeraiAddress, ConstU32<{ MAX_KEY_SHARES_PER_SET / 3 }>>,
     key_pair: KeyPair,
     signature: Signature,
   },
@@ -35,7 +36,8 @@ pub enum Call {
 
 #[derive(Clone, PartialEq, Eq, Debug, scale::Encode, scale::Decode, scale_info::TypeInfo)]
 #[cfg_attr(feature = "borsh", derive(borsh::BorshSerialize, borsh::BorshDeserialize))]
-#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
+#[cfg_attr(feature = "serde", derive(serde::Serialize))]
+#[cfg_attr(all(feature = "std", feature = "serde"), derive(serde::Deserialize))]
 pub enum Event {
   NewSet {
     set: ValidatorSet,