Add no_std support to transcript, dalek-ff-group, ed448, ciphersuite, multiexp, schnorr, and monero-generators

transcript, dalek-ff-group, ed449, and ciphersuite are all usable with no_std
alone. The rest additionally require alloc.

Part of #279.

common/std-shims/Cargo.toml

@@ -0,0 +1,20 @@
+[package]
+name = "std-shims"
+version = "0.1.0"
+description = "A series of std shims to make alloc more feasible"
+license = "MIT"
+repository = "https://github.com/serai-dex/serai/tree/develop/common/std-shims"
+authors = ["Luke Parker <lukeparker5132@gmail.com>"]
+keywords = ["nostd", "no_std", "alloc", "io"]
+edition = "2021"
+
+[package.metadata.docs.rs]
+all-features = true
+rustdoc-args = ["--cfg", "docsrs"]
+
+[dependencies]
+hashbrown = "0.13"
+
+[features]
+std = []
+default = ["std"]

common/std-shims/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 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.

common/std-shims/README.md

@@ -0,0 +1,6 @@
+# std shims
+
+A crate which passes through to std when the default `std` feature is enabled,
+yet provides a series of shims when it isn't.
+
+`HashSet` and `HashMap` are provided via `hashbrown`.

common/std-shims/src/collections.rs

@@ -0,0 +1,7 @@
+#[cfg(feature = "std")]
+pub use std::collections::*;
+
+#[cfg(not(feature = "std"))]
+pub use alloc::collections::*;
+#[cfg(not(feature = "std"))]
+pub use hashbrown::{HashSet, HashMap};

common/std-shims/src/io.rs

@@ -0,0 +1,85 @@
+#[cfg(feature = "std")]
+pub use std::io::*;
+
+#[cfg(not(feature = "std"))]
+mod shims {
+  use core::fmt::{Debug, Formatter};
+  use alloc::{boxed::Box, vec::Vec};
+
+  #[derive(Clone, Copy, PartialEq, Eq, Debug)]
+  pub enum ErrorKind {
+    UnexpectedEof,
+    Other,
+  }
+
+  pub struct Error {
+    kind: ErrorKind,
+    error: Box<dyn Send + Sync>,
+  }
+
+  impl Debug for Error {
+    fn fmt(&self, fmt: &mut Formatter<'_>) -> core::result::Result<(), core::fmt::Error> {
+      fmt.debug_struct("Error").field("kind", &self.kind).finish_non_exhaustive()
+    }
+  }
+
+  impl Error {
+    pub fn new<E: 'static + Send + Sync>(kind: ErrorKind, error: E) -> Error {
+      Error { kind, error: Box::new(error) }
+    }
+
+    pub fn kind(&self) -> ErrorKind {
+      self.kind
+    }
+
+    pub fn into_inner(self) -> Option<Box<dyn Send + Sync>> {
+      Some(self.error)
+    }
+  }
+
+  pub type Result<T> = core::result::Result<T, Error>;
+
+  pub trait Read {
+    fn read(&mut self, buf: &mut [u8]) -> Result<usize>;
+
+    fn read_exact(&mut self, buf: &mut [u8]) -> Result<()> {
+      let read = self.read(buf)?;
+      if read != buf.len() {
+        Err(Error::new(ErrorKind::UnexpectedEof, "reader ran out of bytes"))?;
+      }
+      Ok(())
+    }
+  }
+
+  impl Read for &[u8] {
+    fn read(&mut self, buf: &mut [u8]) -> Result<usize> {
+      let mut read = 0;
+      if self.len() < buf.len() {
+        read = self.len();
+      }
+      buf[.. read].copy_from_slice(&self[.. read]);
+      *self = &self[read ..];
+      Ok(read)
+    }
+  }
+
+  pub trait Write {
+    fn write(&mut self, buf: &[u8]) -> Result<usize>;
+    fn write_all(&mut self, buf: &[u8]) -> Result<()> {
+      if self.write(buf)? != buf.len() {
+        Err(Error::new(ErrorKind::UnexpectedEof, "writer ran out of bytes"))?;
+      }
+      Ok(())
+    }
+  }
+
+  impl Write for Vec<u8> {
+    fn write(&mut self, buf: &[u8]) -> Result<usize> {
+      self.extend(buf);
+      Ok(buf.len())
+    }
+  }
+}
+
+#[cfg(not(feature = "std"))]
+pub use shims::*;

common/std-shims/src/lib.rs

@@ -0,0 +1,24 @@
+#![cfg_attr(not(feature = "std"), no_std)]
+
+#[cfg(not(feature = "std"))]
+#[allow(unused_imports)]
+#[doc(hidden)]
+#[macro_use]
+pub extern crate alloc;
+
+pub mod collections;
+pub mod io;
+
+pub mod str {
+  #[cfg(not(feature = "std"))]
+  pub use alloc::str::*;
+  #[cfg(feature = "std")]
+  pub use std::str::*;
+}
+
+pub mod vec {
+  #[cfg(not(feature = "std"))]
+  pub use alloc::vec::*;
+  #[cfg(feature = "std")]
+  pub use std::vec::*;
+}