Merge branch 'next' into serai-rpc

substrate/primitives/Cargo.toml

@@ -6,7 +6,7 @@ license = "MIT"
 repository = "https://github.com/serai-dex/serai/tree/develop/substrate/primitives"
 authors = ["Luke Parker <lukeparker5132@gmail.com>"]
 edition = "2021"
-rust-version = "1.74"
+rust-version = "1.80"
 
 [package.metadata.docs.rs]
 all-features = true
@@ -18,6 +18,8 @@ workspace = true
 [dependencies]
 zeroize = { version = "^1.5", features = ["derive"], optional = true }
 
+ciphersuite = { path = "../../crypto/ciphersuite", default-features = false, optional = true }
+
 scale = { package = "parity-scale-codec", version = "3", default-features = false, features = ["derive"] }
 scale-info = { version = "2", default-features = false, features = ["derive"] }
 
@@ -36,7 +38,7 @@ frame-support = { git = "https://github.com/serai-dex/substrate", default-featur
 rand_core = { version = "0.6", default-features = false, features = ["getrandom"] }
 
 [features]
-std = ["zeroize", "scale/std", "borsh?/std", "serde?/std", "scale-info/std", "sp-core/std", "sp-runtime/std", "sp-std/std", "frame-support/std"]
+std = ["zeroize", "ciphersuite/std", "scale/std", "borsh?/std", "serde?/std", "scale-info/std", "sp-core/std", "sp-runtime/std", "sp-std/std", "frame-support/std"]
 borsh = ["dep:borsh"]
 serde = ["dep:serde"]
 default = ["std"]

substrate/primitives/src/account.rs

@@ -52,7 +52,7 @@ pub fn borsh_deserialize_signature<R: borsh::io::Read>(
 
 // TODO: Remove this for solely Public?
 #[derive(
-  Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Debug, Encode, Decode, MaxEncodedLen, TypeInfo,
+  Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Debug, Encode, Decode, MaxEncodedLen, TypeInfo,
 )]
 #[cfg_attr(feature = "std", derive(Zeroize))]
 #[cfg_attr(feature = "borsh", derive(BorshSerialize, BorshDeserialize))]
@@ -90,11 +90,22 @@ impl std::fmt::Display for SeraiAddress {
   }
 }
 
+/// Create a Substraate key pair by a name.
+///
+/// This should never be considered to have a secure private key. It has effectively no entropy.
 #[cfg(feature = "std")]
 pub fn insecure_pair_from_name(name: &str) -> Pair {
   Pair::from_string(&format!("//{name}"), None).unwrap()
 }
 
+/// Create a private key for an arbitrary ciphersuite by a name.
+///
+/// This key should never be considered a secure private key. It has effectively no entropy.
+#[cfg(feature = "std")]
+pub fn insecure_arbitrary_key_from_name<C: ciphersuite::Ciphersuite>(name: &str) -> C::F {
+  C::hash_to_F(b"insecure arbitrary key", name.as_bytes())
+}
+
 pub struct AccountLookup;
 impl Lookup for AccountLookup {
   type Source = SeraiAddress;

substrate/primitives/src/constants.rs

@@ -3,6 +3,7 @@ use crate::BlockNumber;
 // 1 MB
 pub const BLOCK_SIZE: u32 = 1024 * 1024;
 // 6 seconds
+// TODO: Use Duration
 pub const TARGET_BLOCK_TIME: u64 = 6;
 
 /// Measured in blocks.

substrate/primitives/src/lib.rs

@@ -63,10 +63,7 @@ pub fn borsh_deserialize_bounded_vec<R: borsh::io::Read, T: BorshDeserialize, co
   vec.try_into().map_err(|_| borsh::io::Error::other("bound exceeded"))
 }
 
-// Monero, our current longest address candidate, has a longest address of featured
-// 1 (enum) + 1 (flags) + 64 (two keys) = 66
-// When JAMTIS arrives, it'll become 112 or potentially even 142 bytes
-pub const MAX_ADDRESS_LEN: u32 = 196;
+pub const MAX_ADDRESS_LEN: u32 = 512;
 
 #[derive(Clone, PartialEq, Eq, Debug, Encode, Decode, MaxEncodedLen, TypeInfo)]
 #[cfg_attr(feature = "borsh", derive(BorshSerialize, BorshDeserialize))]
@@ -94,10 +91,6 @@ impl ExternalAddress {
     Ok(ExternalAddress(address.try_into().map_err(|_| "address length exceeds {MAX_ADDRESS_LEN}")?))
   }
 
-  pub fn address(&self) -> &[u8] {
-    self.0.as_ref()
-  }
-
   #[cfg(feature = "std")]
   pub fn consume(self) -> Vec<u8> {
     self.0.into_inner()
@@ -110,51 +103,6 @@ impl AsRef<[u8]> for ExternalAddress {
   }
 }
 
-// Should be enough for a Uniswap v3 call
-pub const MAX_DATA_LEN: u32 = 512;
-#[derive(Clone, PartialEq, Eq, Debug, Encode, Decode, MaxEncodedLen, TypeInfo)]
-#[cfg_attr(feature = "borsh", derive(BorshSerialize, BorshDeserialize))]
-#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
-pub struct Data(
-  #[cfg_attr(
-    feature = "borsh",
-    borsh(
-      serialize_with = "borsh_serialize_bounded_vec",
-      deserialize_with = "borsh_deserialize_bounded_vec"
-    )
-  )]
-  BoundedVec<u8, ConstU32<{ MAX_DATA_LEN }>>,
-);
-
-#[cfg(feature = "std")]
-impl Zeroize for Data {
-  fn zeroize(&mut self) {
-    self.0.as_mut().zeroize()
-  }
-}
-
-impl Data {
-  #[cfg(feature = "std")]
-  pub fn new(data: Vec<u8>) -> Result<Data, &'static str> {
-    Ok(Data(data.try_into().map_err(|_| "data length exceeds {MAX_DATA_LEN}")?))
-  }
-
-  pub fn data(&self) -> &[u8] {
-    self.0.as_ref()
-  }
-
-  #[cfg(feature = "std")]
-  pub fn consume(self) -> Vec<u8> {
-    self.0.into_inner()
-  }
-}
-
-impl AsRef<[u8]> for Data {
-  fn as_ref(&self) -> &[u8] {
-    self.0.as_ref()
-  }
-}
-
 /// Lexicographically reverses a given byte array.
 pub fn reverse_lexicographic_order<const N: usize>(bytes: [u8; N]) -> [u8; N] {
   let mut res = [0u8; N];

substrate/primitives/src/networks.rs

@@ -15,8 +15,18 @@ use sp_std::{vec, vec::Vec};
 #[cfg(feature = "borsh")]
 use crate::{borsh_serialize_bounded_vec, borsh_deserialize_bounded_vec};
 
+/// Identifier for an embedded elliptic curve.
+#[derive(Clone, Copy, PartialEq, Eq, Hash, Debug, Encode, Decode, MaxEncodedLen, TypeInfo)]
+#[cfg_attr(feature = "std", derive(Zeroize))]
+#[cfg_attr(feature = "borsh", derive(BorshSerialize, BorshDeserialize))]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+pub enum EmbeddedEllipticCurve {
+  Embedwards25519,
+  Secq256k1,
+}
+
 /// The type used to identify external networks.
-#[derive(Clone, Copy, PartialEq, Eq, Hash, Debug, PartialOrd, Ord, TypeInfo)]
+#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Debug, TypeInfo)]
 #[cfg_attr(feature = "std", derive(Zeroize))]
 #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
 pub enum ExternalNetworkId {
@@ -125,6 +135,21 @@ impl BorshDeserialize for NetworkId {
 }
 
 impl ExternalNetworkId {
+  /// The embedded elliptic curve actively used for this network.
+  ///
+  /// This is guaranteed to return `[]`, `[Embedwards25519]`, or
+  /// `[Embedwards25519, *network specific curve*]`.
+  pub fn embedded_elliptic_curves(&self) -> &'static [EmbeddedEllipticCurve] {
+    match self {
+      // We need to generate a Ristretto key for oraclizing and a Secp256k1 key for the network
+      Self::Bitcoin | Self::Ethereum => {
+        &[EmbeddedEllipticCurve::Embedwards25519, EmbeddedEllipticCurve::Secq256k1]
+      }
+      // Since the oraclizing key curve is the same as the network's curve, we only need it
+      Self::Monero => &[EmbeddedEllipticCurve::Embedwards25519],
+    }
+  }
+
   pub fn coins(&self) -> Vec<ExternalCoin> {
     match self {
       Self::Bitcoin => vec![ExternalCoin::Bitcoin],
@@ -135,6 +160,17 @@ impl ExternalNetworkId {
 }
 
 impl NetworkId {
+  /// The embedded elliptic curve actively used for this network.
+  ///
+  /// This is guaranteed to return `[]`, `[Embedwards25519]`, or
+  /// `[Embedwards25519, *network specific curve*]`.
+  pub fn embedded_elliptic_curves(&self) -> &'static [EmbeddedEllipticCurve] {
+    match self {
+      Self::Serai => &[],
+      Self::External(network) => network.embedded_elliptic_curves(),
+    }
+  }
+
   pub fn coins(&self) -> Vec<Coin> {
     match self {
       Self::Serai => vec![Coin::Serai],