Make sp_core and sp_runtime dependencies optional, and bump to latest (#760)

* begin porting over traits; remove Config use of Hash

* port over the Header bits that we need

* sp_core_hashing where possible, move Verify to PairSigner, remove unused errors

* tidy up Config things and move related bits into one place

* fix codegen

* copy Era over

* move AccountId, Address, Signer to Signer trait and a pass over fixing examples

* impl MultiAddress, MultiSignature, AccountId32 and add back to Config (for decoding later)

* Copy over StorageKey, StorageData, StorageChangeSet

* subxt core compiling with no sp_core or sp_runtime

* Get examples compiling

* pass over fixing tests

* cargo fmt

* clippy tweaks and update polkadot.rs

* fix codegen docs

* port over special DigestItem encoding/decoding

* clippy and doc fixes

* cargo fmt and example fix

* more cargo fmt-ing...

* substrate-extra to substrate-compat

* cargo.toml comments

* simplify PairSigner trait bounds

* move RPC types to a separate file

* fix docs

* Add some tests for things and other PR feedback

* bump to latest sp deps

* avoid needing substrate-compat feature in a test

subxt/src/utils/account_id.rs

@@ -0,0 +1,203 @@
+// Copyright 2019-2022 Parity Technologies (UK) Ltd.
+// This file is dual-licensed as Apache-2.0 or GPL-3.0.
+// see LICENSE for license details.
+
+//! The "default" Substrate/Polkadot AccountId. This is used in codegen, as well as signing related bits.
+//! This doesn't contain much functionality itself, but is easy to convert to/from an `sp_core::AccountId32`
+//! for instance, to gain functionality without forcing a dependency on Substrate crates here.
+
+use codec::{
+    Decode,
+    Encode,
+};
+use serde::Serialize;
+
+/// A 32-byte cryptographic identifier. This is a simplified version of Substrate's
+/// `sp_core::crypto::AccountId32`. To obtain more functionality, convert this into
+/// that type.
+#[derive(Clone, Eq, PartialEq, Ord, PartialOrd, Encode, Decode, Debug)]
+pub struct AccountId32(pub [u8; 32]);
+
+impl AsRef<[u8]> for AccountId32 {
+    fn as_ref(&self) -> &[u8] {
+        &self.0[..]
+    }
+}
+
+impl AsRef<[u8; 32]> for AccountId32 {
+    fn as_ref(&self) -> &[u8; 32] {
+        &self.0
+    }
+}
+
+impl From<[u8; 32]> for AccountId32 {
+    fn from(x: [u8; 32]) -> Self {
+        AccountId32(x)
+    }
+}
+
+impl AccountId32 {
+    // Return the ss58-check string for this key. Adapted from `sp_core::crypto`. We need this to
+    // serialize our account appropriately but otherwise don't care.
+    fn to_ss58check(&self) -> String {
+        // For serializing to a string to obtain the account nonce, we use the default substrate
+        // prefix (since we have no way to otherwise pick one). It doesn't really matter, since when
+        // it's deserialized back in system_accountNextIndex, we ignore this (so long as it's valid).
+        const SUBSTRATE_SS58_PREFIX: u8 = 42;
+        // prefix <= 63 just take up one byte at the start:
+        let mut v = vec![SUBSTRATE_SS58_PREFIX];
+        // then push the account ID bytes.
+        v.extend(self.0);
+        // then push a 2 byte checksum of what we have so far.
+        let r = ss58hash(&v);
+        v.extend(&r[0..2]);
+        // then encode to base58.
+        use base58::ToBase58;
+        v.to_base58()
+    }
+
+    // This isn't strictly needed, but to give our AccountId32 a little more usefulness, we also
+    // implement the logic needed to decode an AccountId32 from an SS58 encoded string. This is exposed
+    // via a `FromStr` impl.
+    fn from_ss58check(s: &str) -> Result<Self, FromSs58Error> {
+        const CHECKSUM_LEN: usize = 2;
+        let body_len = 32;
+
+        use base58::FromBase58;
+        let data = s.from_base58().map_err(|_| FromSs58Error::BadBase58)?;
+        if data.len() < 2 {
+            return Err(FromSs58Error::BadLength)
+        }
+        let prefix_len = match data[0] {
+            0..=63 => 1,
+            64..=127 => 2,
+            _ => return Err(FromSs58Error::InvalidPrefix),
+        };
+        if data.len() != prefix_len + body_len + CHECKSUM_LEN {
+            return Err(FromSs58Error::BadLength)
+        }
+        let hash = ss58hash(&data[0..body_len + prefix_len]);
+        let checksum = &hash[0..CHECKSUM_LEN];
+        if data[body_len + prefix_len..body_len + prefix_len + CHECKSUM_LEN] != *checksum
+        {
+            // Invalid checksum.
+            return Err(FromSs58Error::InvalidChecksum)
+        }
+
+        let result = data[prefix_len..body_len + prefix_len]
+            .try_into()
+            .map_err(|_| FromSs58Error::BadLength)?;
+        Ok(AccountId32(result))
+    }
+}
+
+/// An error obtained from trying to interpret an SS58 encoded string into an AccountId32
+#[derive(thiserror::Error, Clone, Copy, Eq, PartialEq, Debug)]
+#[allow(missing_docs)]
+pub enum FromSs58Error {
+    #[error("Base 58 requirement is violated")]
+    BadBase58,
+    #[error("Length is bad")]
+    BadLength,
+    #[error("Invalid checksum")]
+    InvalidChecksum,
+    #[error("Invalid SS58 prefix byte.")]
+    InvalidPrefix,
+}
+
+// We do this just to get a checksum to help verify the validity of the address in to_ss58check
+fn ss58hash(data: &[u8]) -> Vec<u8> {
+    use blake2::{
+        Blake2b512,
+        Digest,
+    };
+    const PREFIX: &[u8] = b"SS58PRE";
+    let mut ctx = Blake2b512::new();
+    ctx.update(PREFIX);
+    ctx.update(data);
+    ctx.finalize().to_vec()
+}
+
+impl Serialize for AccountId32 {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        serializer.serialize_str(&self.to_ss58check())
+    }
+}
+
+impl std::fmt::Display for AccountId32 {
+    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+        write!(f, "{}", self.to_ss58check())
+    }
+}
+
+impl std::str::FromStr for AccountId32 {
+    type Err = FromSs58Error;
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        AccountId32::from_ss58check(s)
+    }
+}
+
+// Improve compat with the substrate version if we're using those crates:
+#[cfg(feature = "substrate-compat")]
+mod substrate_impls {
+    use super::*;
+
+    impl From<sp_runtime::AccountId32> for AccountId32 {
+        fn from(value: sp_runtime::AccountId32) -> Self {
+            Self(value.into())
+        }
+    }
+    impl From<sp_core::sr25519::Public> for AccountId32 {
+        fn from(value: sp_core::sr25519::Public) -> Self {
+            let acc: sp_runtime::AccountId32 = value.into();
+            acc.into()
+        }
+    }
+    impl From<sp_core::ed25519::Public> for AccountId32 {
+        fn from(value: sp_core::ed25519::Public) -> Self {
+            let acc: sp_runtime::AccountId32 = value.into();
+            acc.into()
+        }
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use super::*;
+
+    use sp_core::crypto::Ss58Codec;
+    use sp_keyring::AccountKeyring;
+
+    #[test]
+    fn ss58_is_compatible_with_substrate_impl() {
+        let keyrings = vec![
+            AccountKeyring::Alice,
+            AccountKeyring::Bob,
+            AccountKeyring::Charlie,
+        ];
+
+        for keyring in keyrings {
+            let substrate_account = keyring.to_account_id();
+            // Avoid "From" impl hidden behind "substrate-compat" feature so that this test
+            // can work either way:
+            let local_account = AccountId32(substrate_account.clone().into());
+
+            // Both should encode to ss58 the same way:
+            let substrate_ss58 = substrate_account.to_ss58check();
+            assert_eq!(substrate_ss58, local_account.to_ss58check());
+
+            // Both should decode from ss58 back to the same:
+            assert_eq!(
+                sp_core::crypto::AccountId32::from_ss58check(&substrate_ss58).unwrap(),
+                substrate_account
+            );
+            assert_eq!(
+                AccountId32::from_ss58check(&substrate_ss58).unwrap(),
+                local_account
+            );
+        }
+    }
+}

subxt/src/utils/mod.rs

@@ -4,7 +4,10 @@
 
 //! Miscellaneous utility helpers.
 
+pub mod account_id;
 pub mod bits;
+pub mod multi_address;
+pub mod multi_signature;
 
 use codec::{
     Decode,
@@ -13,6 +16,18 @@ use codec::{
 };
 use derivative::Derivative;
 
+pub use account_id::AccountId32;
+pub use multi_address::MultiAddress;
+pub use multi_signature::MultiSignature;
+
+// Used in codegen
+#[doc(hidden)]
+pub use primitive_types::{
+    H160,
+    H256,
+    H512,
+};
+
 /// Wraps an already encoded byte vector, prevents being encoded as a raw byte vector as part of
 /// the transaction payload
 #[derive(Clone, Debug, Eq, PartialEq)]

subxt/src/utils/multi_address.rs

@@ -0,0 +1,66 @@
+// Copyright 2019-2022 Parity Technologies (UK) Ltd.
+// This file is dual-licensed as Apache-2.0 or GPL-3.0.
+// see LICENSE for license details.
+
+//! The "default" Substrate/Polkadot Address type. This is used in codegen, as well as signing related bits.
+//! This doesn't contain much functionality itself, but is easy to convert to/from an `sp_runtime::MultiAddress`
+//! for instance, to gain functionality without forcing a dependency on Substrate crates here.
+
+use codec::{
+    Decode,
+    Encode,
+};
+
+/// A multi-format address wrapper for on-chain accounts. This is a simplified version of Substrate's
+/// `sp_runtime::MultiAddress`. To obtain more functionality, convert this into that type (this conversion
+/// functionality is provided via `From` impls if the `substrate-compat` feature is enabled).
+#[derive(Clone, Eq, PartialEq, Ord, PartialOrd, Encode, Decode, Debug)]
+pub enum MultiAddress<AccountId, AccountIndex> {
+    /// It's an account ID (pubkey).
+    Id(AccountId),
+    /// It's an account index.
+    Index(#[codec(compact)] AccountIndex),
+    /// It's some arbitrary raw bytes.
+    Raw(Vec<u8>),
+    /// It's a 32 byte representation.
+    Address32([u8; 32]),
+    /// Its a 20 byte representation.
+    Address20([u8; 20]),
+}
+
+impl<AccountId, AccountIndex> From<AccountId> for MultiAddress<AccountId, AccountIndex> {
+    fn from(a: AccountId) -> Self {
+        Self::Id(a)
+    }
+}
+
+// Improve compat with the substrate version if we're using those crates:
+#[cfg(feature = "substrate-compat")]
+mod substrate_impls {
+    use super::{
+        super::AccountId32,
+        *,
+    };
+
+    impl<N> From<sp_runtime::AccountId32> for MultiAddress<AccountId32, N> {
+        fn from(value: sp_runtime::AccountId32) -> Self {
+            let val: AccountId32 = value.into();
+            val.into()
+        }
+    }
+
+    impl<Id, N> From<sp_runtime::MultiAddress<Id, N>> for MultiAddress<AccountId32, N>
+    where
+        Id: Into<AccountId32>,
+    {
+        fn from(value: sp_runtime::MultiAddress<Id, N>) -> Self {
+            match value {
+                sp_runtime::MultiAddress::Id(v) => Self::Id(v.into()),
+                sp_runtime::MultiAddress::Index(v) => Self::Index(v),
+                sp_runtime::MultiAddress::Raw(v) => Self::Raw(v),
+                sp_runtime::MultiAddress::Address32(v) => Self::Address32(v),
+                sp_runtime::MultiAddress::Address20(v) => Self::Address20(v),
+            }
+        }
+    }
+}

subxt/src/utils/multi_signature.rs

@@ -0,0 +1,61 @@
+// Copyright 2019-2022 Parity Technologies (UK) Ltd.
+// This file is dual-licensed as Apache-2.0 or GPL-3.0.
+// see LICENSE for license details.
+
+//! The "default" Substrate/Polkadot Signature type. This is used in codegen, as well as signing related bits.
+//! This doesn't contain much functionality itself, but is easy to convert to/from an `sp_runtime::MultiSignature`
+//! for instance, to gain functionality without forcing a dependency on Substrate crates here.
+
+use codec::{
+    Decode,
+    Encode,
+};
+
+/// Signature container that can store known signature types. This is a simplified version of
+/// `sp_runtime::MultiSignature`. To obtain more functionality, convert this into that type.
+#[derive(Clone, Eq, PartialEq, Ord, PartialOrd, Encode, Decode, Debug)]
+pub enum MultiSignature {
+    /// An Ed25519 signature.
+    Ed25519([u8; 64]),
+    /// An Sr25519 signature.
+    Sr25519([u8; 64]),
+    /// An ECDSA/SECP256k1 signature (a 512-bit value, plus 8 bits for recovery ID).
+    Ecdsa([u8; 65]),
+}
+
+// Improve compat with the substrate version if we're using those crates:
+#[cfg(feature = "substrate-compat")]
+mod substrate_impls {
+    use super::*;
+
+    impl From<sp_runtime::MultiSignature> for MultiSignature {
+        fn from(value: sp_runtime::MultiSignature) -> Self {
+            match value {
+                sp_runtime::MultiSignature::Ed25519(s) => Self::Ed25519(s.0),
+                sp_runtime::MultiSignature::Sr25519(s) => Self::Sr25519(s.0),
+                sp_runtime::MultiSignature::Ecdsa(s) => Self::Ecdsa(s.0),
+            }
+        }
+    }
+
+    impl From<sp_core::ed25519::Signature> for MultiSignature {
+        fn from(value: sp_core::ed25519::Signature) -> Self {
+            let sig: sp_runtime::MultiSignature = value.into();
+            sig.into()
+        }
+    }
+
+    impl From<sp_core::sr25519::Signature> for MultiSignature {
+        fn from(value: sp_core::sr25519::Signature) -> Self {
+            let sig: sp_runtime::MultiSignature = value.into();
+            sig.into()
+        }
+    }
+
+    impl From<sp_core::ecdsa::Signature> for MultiSignature {
+        fn from(value: sp_core::ecdsa::Signature) -> Self {
+            let sig: sp_runtime::MultiSignature = value.into();
+            sig.into()
+        }
+    }
+}