Use the serai_abi::Call in the actual Transaction type

We prior required they had the same encoding, yet this ensures they do by
making them one and the same. This does require an large, ugly, From/TryInto
block which is deemed preferable for moving this more and more into syntax
(from semantics).

Further improvements (notably re: Extra) is possible, and this already lets us
strip some members from the Call enum.

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 },
+    })
+  }
+}