Merge branch 'next' into next-polkadot-sdk

patches/ciphersuite/Cargo.toml

@@ -16,13 +16,19 @@ rustdoc-args = ["--cfg", "docsrs"]
 workspace = true
 
 [dependencies]
+std-shims = { path = "../../common/std-shims", version = "0.1.4", default-features = false, optional = true }
+
+zeroize = { version = "1", default-features = false }
 ciphersuite = { path = "../../crypto/ciphersuite", default-features = false }
+
 dalek-ff-group = { path = "../../crypto/dalek-ff-group", default-features = false, optional = true }
 
 [features]
-alloc = ["ciphersuite/alloc"]
+alloc = ["std-shims", "zeroize/alloc", "ciphersuite/alloc", "dalek-ff-group/alloc"]
 std = [
   "alloc",
+  "std-shims/std",
+  "zeroize/std",
   "ciphersuite/std",
   "dalek-ff-group?/std",
 ]

patches/ciphersuite/README.md

@@ -1,4 +1,4 @@
 # Ciphersuite
 
-Patch for the `crates.io` ciphersuite to use the in-tree ciphersuite, resolving
-breaking changes made since.
+Patch for the `crates.io` `ciphersuite` to use the in-tree `ciphersuite`,
+resolving relevant breaking changes made since.

patches/ciphersuite/src/lib.rs

@@ -1,5 +1,33 @@
 #![cfg_attr(not(feature = "std"), no_std)]
 
-pub use ciphersuite::*;
+use std_shims::io;
+
+use zeroize::Zeroize;
+pub use ciphersuite::group;
+use group::{*, ff::*, prime::PrimeGroup};
+
+pub trait Ciphersuite: 'static + Send + Sync {
+  type F: PrimeField + PrimeFieldBits + Zeroize;
+  type G: Group<Scalar = Self::F> + GroupOps + PrimeGroup + Zeroize;
+  #[cfg(feature = "alloc")]
+  #[allow(non_snake_case)]
+  fn read_F<R: io::Read>(reader: &mut R) -> io::Result<Self::F>;
+  #[cfg(feature = "alloc")]
+  #[allow(non_snake_case)]
+  fn read_G<R: io::Read>(reader: &mut R) -> io::Result<Self::G>;
+}
+impl<C: ciphersuite::GroupIo> Ciphersuite for C {
+  type F = <C as ciphersuite::WrappedGroup>::F;
+  type G = <C as ciphersuite::WrappedGroup>::G;
+  #[cfg(feature = "alloc")]
+  fn read_F<R: io::Read>(reader: &mut R) -> io::Result<Self::F> {
+    <C as ciphersuite::GroupIo>::read_F(reader)
+  }
+  #[cfg(feature = "alloc")]
+  fn read_G<R: io::Read>(reader: &mut R) -> io::Result<Self::G> {
+    <C as ciphersuite::GroupIo>::read_G(reader)
+}
+}
+
 #[cfg(feature = "ed25519")]
 pub use dalek_ff_group::Ed25519;

patches/dalek-ff-group/Cargo.toml

@@ -0,0 +1,29 @@
+[package]
+name = "dalek-ff-group"
+version = "0.5.99"
+description = "ff/group bindings around curve25519-dalek"
+license = "MIT"
+repository = "https://github.com/serai-dex/serai/tree/develop/crypto/dalek-ff-group"
+authors = ["Luke Parker <lukeparker5132@gmail.com>"]
+keywords = ["curve25519", "ed25519", "ristretto", "dalek", "group"]
+edition = "2021"
+rust-version = "1.85"
+
+[package.metadata.docs.rs]
+all-features = true
+rustdoc-args = ["--cfg", "docsrs"]
+
+[lints]
+workspace = true
+
+[dependencies]
+dalek-ff-group = { path = "../../crypto/dalek-ff-group", default-features = false }
+
+crypto-bigint-05 = { package = "crypto-bigint", version = "0.5", default-features = false, features = ["zeroize"] }
+crypto-bigint = { version = "0.6", default-features = false, features = ["zeroize"] }
+prime-field = { path = "../../crypto/prime-field", default-features = false }
+
+[features]
+alloc = ["dalek-ff-group/alloc", "crypto-bigint-05/alloc", "crypto-bigint/alloc", "prime-field/alloc"]
+std = ["alloc", "dalek-ff-group/std", "prime-field/std"]
+default = ["std"]

patches/dalek-ff-group/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2022-2025 Luke Parker
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

patches/dalek-ff-group/README.md

@@ -0,0 +1,4 @@
+# Dalek FF/Group
+
+Patch for the `crates.io` `dalek-ff-group` to use the in-tree `dalek-ff-group`,
+resolving relevant breaking changes made since.

patches/dalek-ff-group/src/lib.rs

@@ -0,0 +1,44 @@
+#![allow(deprecated)]
+#![cfg_attr(docsrs, feature(doc_auto_cfg))]
+#![no_std] // Prevents writing new code, in what should be a simple wrapper, which requires std
+#![doc = include_str!("../README.md")]
+#![allow(clippy::redundant_closure_call)]
+
+pub use dalek_ff_group::{Scalar, EdwardsPoint, RistrettoPoint, Ed25519, Ristretto};
+
+type ThirtyTwoArray = [u8; 32];
+prime_field::odd_prime_field_with_specific_repr!(
+  FieldElement,
+  "0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffed",
+  "02",
+  false,
+  crate::ThirtyTwoArray
+);
+
+impl FieldElement {
+  /// Create a FieldElement from a `crypto_bigint::U256`.
+  ///
+  /// This will reduce the `U256` by the modulus, into a member of the field.
+  #[deprecated]
+  pub const fn from_u256(u256: &crypto_bigint_05::U256) -> Self {
+    const MODULUS: crypto_bigint::U256 = crypto_bigint::U256::from_be_hex(
+      "7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffed",
+    );
+    let mut u256 = crypto_bigint::U256::from_words(*u256.as_words());
+    loop {
+      let result = FieldElement::from_bytes(&u256.to_le_bytes());
+      if let Some(result) = result {
+        return result;
+      }
+      u256 = u256.wrapping_sub(&MODULUS);
+    }
+  }
+
+  /// Create a `FieldElement` from the reduction of a 512-bit number.
+  ///
+  /// The bytes are interpreted in little-endian format.
+  #[deprecated]
+  pub fn wide_reduce(value: [u8; 64]) -> Self {
+    <FieldElement as prime_field::ff::FromUniformBytes<_>>::from_uniform_bytes(&value)
+  }
+}