Replace bincode with borsh (#452)

* Add SignalsConfig to chain_spec

* Correct multiexp feature flagging for rand_core std

* Remove bincode for borsh

Replaces a non-canonical encoding with a canonical encoding which additionally
should be faster.

Also fixes an issue where we used bincode in transcripts where it cannot be
trusted.

This ended up fixing a myriad of other bugs observed, unfortunately.
Accordingly, it either has to be merged or the bug fixes from it must be ported
to a new PR.

* Make serde optional, minimize usage

* Make borsh an optional dependency of substrate/ crates

* Remove unused dependencies

* Use [u8; 64] where possible in the processor messages

* Correct borsh feature flagging

substrate/primitives/Cargo.toml

@@ -15,15 +15,18 @@ rustdoc-args = ["--cfg", "docsrs"]
 [dependencies]
 zeroize = { version = "^1.5", features = ["derive"], optional = true }
 
-serde = { version = "1", default-features = false, features = ["derive", "alloc"] }
-
 scale = { package = "parity-scale-codec", version = "3", default-features = false, features = ["derive"] }
 scale-info = { version = "2", default-features = false, features = ["derive"] }
 
+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-application-crypto = { git = "https://github.com/serai-dex/substrate", default-features = false }
 sp-core = { git = "https://github.com/serai-dex/substrate", default-features = false }
 sp-runtime = { git = "https://github.com/serai-dex/substrate", default-features = false }
 
 [features]
-std = ["zeroize", "scale/std", "serde/std", "scale-info/std", "sp-core/std", "sp-runtime/std"]
+std = ["zeroize", "scale/std", "borsh?/std", "serde?/std", "scale-info/std", "sp-core/std", "sp-runtime/std"]
+borsh = ["dep:borsh"]
+serde = ["dep:serde"]
 default = ["std"]

substrate/primitives/src/account.rs

@@ -1,6 +1,9 @@
 #[cfg(feature = "std")]
 use zeroize::Zeroize;
 
+#[cfg(feature = "borsh")]
+use borsh::{BorshSerialize, BorshDeserialize};
+#[cfg(feature = "serde")]
 use serde::{Serialize, Deserialize};
 
 use scale::{Encode, Decode, MaxEncodedLen};
@@ -15,22 +18,44 @@ use sp_runtime::traits::{LookupError, Lookup, StaticLookup};
 
 pub type PublicKey = Public;
 
+#[cfg(feature = "borsh")]
+pub fn borsh_serialize_public<W: borsh::io::Write>(
+  public: &Public,
+  writer: &mut W,
+) -> Result<(), borsh::io::Error> {
+  borsh::BorshSerialize::serialize(&public.0, writer)
+}
+
+#[cfg(feature = "borsh")]
+pub fn borsh_deserialize_public<R: borsh::io::Read>(
+  reader: &mut R,
+) -> Result<Public, borsh::io::Error> {
+  let public: [u8; 32] = borsh::BorshDeserialize::deserialize_reader(reader)?;
+  Ok(Public(public))
+}
+
+#[cfg(feature = "borsh")]
+pub fn borsh_serialize_signature<W: borsh::io::Write>(
+  signature: &Signature,
+  writer: &mut W,
+) -> Result<(), borsh::io::Error> {
+  borsh::BorshSerialize::serialize(&signature.0, writer)
+}
+
+#[cfg(feature = "borsh")]
+pub fn borsh_deserialize_signature<R: borsh::io::Read>(
+  reader: &mut R,
+) -> Result<Signature, borsh::io::Error> {
+  let signature: [u8; 64] = borsh::BorshDeserialize::deserialize_reader(reader)?;
+  Ok(Signature(signature))
+}
+
 #[derive(
-  Clone,
-  Copy,
-  PartialEq,
-  Eq,
-  PartialOrd,
-  Ord,
-  Debug,
-  Serialize,
-  Deserialize,
-  Encode,
-  Decode,
-  MaxEncodedLen,
-  TypeInfo,
+  Clone, Copy, PartialEq, Eq, PartialOrd, Ord, 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 struct SeraiAddress(pub [u8; 32]);
 impl SeraiAddress {
   pub fn new(key: [u8; 32]) -> SeraiAddress {

substrate/primitives/src/amount.rs

@@ -6,6 +6,9 @@ use core::{
 #[cfg(feature = "std")]
 use zeroize::Zeroize;
 
+#[cfg(feature = "borsh")]
+use borsh::{BorshSerialize, BorshDeserialize};
+#[cfg(feature = "serde")]
 use serde::{Serialize, Deserialize};
 
 use scale::{Encode, Decode, MaxEncodedLen};
@@ -19,20 +22,11 @@ use scale_info::TypeInfo;
 pub type SubstrateAmount = u64;
 /// The type used for amounts.
 #[derive(
-  Clone,
-  Copy,
-  PartialEq,
-  Eq,
-  PartialOrd,
-  Debug,
-  Serialize,
-  Deserialize,
-  Encode,
-  Decode,
-  MaxEncodedLen,
-  TypeInfo,
+  Clone, Copy, PartialEq, Eq, PartialOrd, 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 struct Amount(pub SubstrateAmount);
 
 impl Add for Amount {

substrate/primitives/src/balance.rs

@@ -3,6 +3,9 @@ use core::ops::{Add, Sub, Mul};
 #[cfg(feature = "std")]
 use zeroize::Zeroize;
 
+#[cfg(feature = "borsh")]
+use borsh::{BorshSerialize, BorshDeserialize};
+#[cfg(feature = "serde")]
 use serde::{Serialize, Deserialize};
 
 use scale::{Encode, Decode, MaxEncodedLen};
@@ -13,9 +16,11 @@ use crate::{Coin, Amount};
 /// The type used for balances (a Coin and Balance).
 #[rustfmt::skip]
 #[derive(
-  Clone, Copy, PartialEq, Eq, Debug, Serialize, Deserialize, Encode, Decode, MaxEncodedLen, TypeInfo,
+  Clone, Copy, PartialEq, Eq, 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 struct Balance {
   pub coin: Coin,
   pub amount: Amount,

substrate/primitives/src/block.rs

@@ -1,6 +1,9 @@
 #[cfg(feature = "std")]
 use zeroize::Zeroize;
 
+#[cfg(feature = "borsh")]
+use borsh::{BorshSerialize, BorshDeserialize};
+#[cfg(feature = "serde")]
 use serde::{Serialize, Deserialize};
 
 use scale::{Encode, Decode, MaxEncodedLen};
@@ -10,21 +13,11 @@ use sp_core::H256;
 
 /// The type used to identify block numbers.
 #[derive(
-  Clone,
-  Copy,
-  Default,
-  PartialEq,
-  Eq,
-  Hash,
-  Debug,
-  Serialize,
-  Deserialize,
-  Encode,
-  Decode,
-  MaxEncodedLen,
-  TypeInfo,
+  Clone, Copy, Default, 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 struct BlockNumber(pub u64);
 impl From<u64> for BlockNumber {
   fn from(number: u64) -> BlockNumber {
@@ -37,21 +30,10 @@ impl From<u64> for BlockNumber {
 // If a block exists with a hash which isn't 32-bytes, it can be hashed into a value with 32-bytes
 // This would require the processor to maintain a mapping of 32-byte IDs to actual hashes, which
 // would be fine
-#[derive(
-  Clone,
-  Copy,
-  PartialEq,
-  Eq,
-  Hash,
-  Debug,
-  Serialize,
-  Deserialize,
-  Encode,
-  Decode,
-  MaxEncodedLen,
-  TypeInfo,
-)]
+#[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 struct BlockHash(pub [u8; 32]);
 
 impl AsRef<[u8]> for BlockHash {

substrate/primitives/src/lib.rs

@@ -5,6 +5,9 @@
 #[cfg(feature = "std")]
 use zeroize::Zeroize;
 
+#[cfg(feature = "borsh")]
+use borsh::{BorshSerialize, BorshDeserialize};
+#[cfg(feature = "serde")]
 use serde::{Serialize, Deserialize};
 
 use scale::{Encode, Decode, MaxEncodedLen};
@@ -29,16 +32,40 @@ pub use balance::*;
 mod account;
 pub use account::*;
 
+#[cfg(feature = "borsh")]
+pub fn borsh_serialize_bounded_vec<W: borsh::io::Write, T: BorshSerialize, const B: u32>(
+  bounded: &BoundedVec<T, ConstU32<B>>,
+  writer: &mut W,
+) -> Result<(), borsh::io::Error> {
+  borsh::BorshSerialize::serialize(bounded.as_slice(), writer)
+}
+
+#[cfg(feature = "borsh")]
+pub fn borsh_deserialize_bounded_vec<R: borsh::io::Read, T: BorshDeserialize, const B: u32>(
+  reader: &mut R,
+) -> Result<BoundedVec<T, ConstU32<B>>, borsh::io::Error> {
+  let vec: Vec<T> = borsh::BorshDeserialize::deserialize_reader(reader)?;
+  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;
 
-#[derive(
-  Clone, PartialEq, Eq, Debug, Serialize, Deserialize, Encode, Decode, MaxEncodedLen, TypeInfo,
-)]
-pub struct ExternalAddress(BoundedVec<u8, ConstU32<{ MAX_ADDRESS_LEN }>>);
-
+#[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 ExternalAddress(
+  #[cfg_attr(
+    feature = "borsh",
+    borsh(
+      serialize_with = "borsh_serialize_bounded_vec",
+      deserialize_with = "borsh_deserialize_bounded_vec"
+    )
+  )]
+  BoundedVec<u8, ConstU32<{ MAX_ADDRESS_LEN }>>,
+);
 #[cfg(feature = "std")]
 impl Zeroize for ExternalAddress {
   fn zeroize(&mut self) {
@@ -70,10 +97,19 @@ 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, Serialize, Deserialize, Encode, Decode, MaxEncodedLen, TypeInfo,
-)]
-pub struct Data(BoundedVec<u8, ConstU32<{ MAX_DATA_LEN }>>);
+#[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 {

substrate/primitives/src/networks.rs

@@ -1,29 +1,24 @@
 #[cfg(feature = "std")]
 use zeroize::Zeroize;
 
-use serde::{Serialize, Deserialize};
-
 use scale::{Encode, Decode, MaxEncodedLen};
 use scale_info::TypeInfo;
 
+#[cfg(feature = "borsh")]
+use borsh::{BorshSerialize, BorshDeserialize};
+#[cfg(feature = "serde")]
+use serde::{Serialize, Deserialize};
+
 use sp_core::{ConstU32, bounded::BoundedVec};
 
+#[cfg(feature = "borsh")]
+use crate::{borsh_serialize_bounded_vec, borsh_deserialize_bounded_vec};
+
 /// The type used to identify networks.
-#[derive(
-  Clone,
-  Copy,
-  PartialEq,
-  Eq,
-  Hash,
-  Debug,
-  Serialize,
-  Deserialize,
-  Encode,
-  Decode,
-  MaxEncodedLen,
-  TypeInfo,
-)]
+#[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 NetworkId {
   Serai,
   Bitcoin,
@@ -38,22 +33,11 @@ pub const COINS: [Coin; 5] = [Coin::Serai, Coin::Bitcoin, Coin::Ether, Coin::Dai
 
 /// The type used to identify coins.
 #[derive(
-  Clone,
-  Copy,
-  PartialEq,
-  Eq,
-  PartialOrd,
-  Ord,
-  Hash,
-  Debug,
-  Serialize,
-  Deserialize,
-  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))]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
 pub enum Coin {
   Serai,
   Bitcoin,
@@ -123,10 +107,17 @@ impl Coin {
 pub const MAX_COINS_PER_NETWORK: u32 = 8;
 
 /// Network definition.
-#[derive(
-  Clone, PartialEq, Eq, Debug, Serialize, Deserialize, Encode, Decode, MaxEncodedLen, TypeInfo,
-)]
+#[derive(Clone, PartialEq, Eq, Debug)]
+#[cfg_attr(feature = "borsh", derive(BorshSerialize, BorshDeserialize))]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
 pub struct Network {
+  #[cfg_attr(
+    feature = "borsh",
+    borsh(
+      serialize_with = "borsh_serialize_bounded_vec",
+      deserialize_with = "borsh_deserialize_bounded_vec"
+    )
+  )]
   coins: BoundedVec<Coin, ConstU32<{ MAX_COINS_PER_NETWORK }>>,
 }