broken commit, prelude but no replacement of all std types

subxt/Cargo.toml

@@ -20,16 +20,13 @@ workspace = true
 [features]
 # For dev and documentation reasons we enable more features than are often desired.
 # it's recommended to use `--no-default-features` and then select what you need.
-default = ["jsonrpsee", "native"]
+default = ["std", "jsonrpsee", "native"]
+
+std = ["bitvec/std"]
 
 # Enable this for native (ie non web/wasm builds).
 # Exactly 1 of "web" and "native" is expected.
-native = [
-    "jsonrpsee?/async-client",
-    "jsonrpsee?/client-ws-transport-native-tls",
-    "subxt-lightclient?/native",
-    "tokio-util"
-]
+native = ["jsonrpsee?/async-client", "jsonrpsee?/client-ws-transport-native-tls", "subxt-lightclient?/native", "tokio-util"]
 
 # Enable this for web/wasm builds.
 # Exactly 1 of "web" and "native" is expected.
@@ -55,6 +52,7 @@ unstable-light-client = ["subxt-lightclient", "tokio-stream"]
 
 [dependencies]
 async-trait = { workspace = true }
+cfg-if = { workspace = true }
 codec = { package = "parity-scale-codec", workspace = true, features = ["derive"] }
 scale-info = { workspace = true }
 scale-value = { workspace = true }
@@ -68,7 +66,7 @@ serde_json = { workspace = true, features = ["raw_value"] }
 thiserror = { workspace = true }
 tracing = { workspace = true }
 frame-metadata = { workspace = true }
-derivative = { workspace = true }
+derivative = { workspace = true, features = ["use_core"] }
 either = { workspace = true }
 
 # Provides some deserialization, types like U256/H256 and hashing impls like twox/blake256:

subxt/src/backend/legacy/mod.rs

@@ -13,6 +13,7 @@ use crate::backend::{
     TransactionStatus,
 };
 use crate::{config::Header, Config, Error};
+use crate::prelude::*;
 use async_trait::async_trait;
 use futures::{future, future::Either, stream, Future, FutureExt, Stream, StreamExt};
 use std::collections::VecDeque;

subxt/src/backend/legacy/rpc_methods.rs

@@ -7,6 +7,7 @@
 use crate::backend::rpc::{rpc_params, RpcClient, RpcSubscription};
 use crate::metadata::Metadata;
 use crate::{Config, Error};
+use crate::prelude::*;
 use codec::Decode;
 use derivative::Derivative;
 use primitive_types::U256;

subxt/src/backend/mod.rs

@@ -13,6 +13,7 @@ pub mod unstable;
 use crate::error::Error;
 use crate::metadata::Metadata;
 use crate::Config;
+use crate::prelude::*;
 use async_trait::async_trait;
 use codec::{Decode, Encode};
 use futures::{Stream, StreamExt};

subxt/src/backend/rpc/jsonrpsee_impl.rs

@@ -4,6 +4,7 @@
 
 use super::{RawRpcFuture, RawRpcSubscription, RpcClientT};
 use crate::error::RpcError;
+use crate::prelude::*;
 use futures::stream::{StreamExt, TryStreamExt};
 use jsonrpsee::{
     core::{

subxt/src/backend/rpc/rpc_client.rs

@@ -4,6 +4,7 @@
 
 use super::{RawRpcSubscription, RpcClientT};
 use crate::error::Error;
+use crate::prelude::*;
 use futures::{Stream, StreamExt};
 use serde::{de::DeserializeOwned, Serialize};
 use serde_json::value::RawValue;

subxt/src/backend/rpc/rpc_client_t.rs

@@ -3,6 +3,7 @@
 // see LICENSE for license details.
 
 use crate::error::RpcError;
+use crate::prelude::*;
 use futures::Stream;
 use std::{future::Future, pin::Pin};
 

subxt/src/backend/unstable/follow_stream.rs

@@ -5,6 +5,7 @@
 use super::rpc_methods::{FollowEvent, UnstableRpcMethods};
 use crate::config::Config;
 use crate::error::Error;
+use crate::prelude::*;
 use futures::{FutureExt, Stream, StreamExt};
 use std::future::Future;
 use std::pin::Pin;

subxt/src/backend/unstable/follow_stream_driver.rs

@@ -6,6 +6,7 @@ use super::follow_stream_unpin::{BlockRef, FollowStreamMsg, FollowStreamUnpin};
 use crate::backend::unstable::rpc_methods::{FollowEvent, Initialized, RuntimeEvent};
 use crate::config::BlockHash;
 use crate::error::Error;
+use crate::prelude::*;
 use futures::stream::{Stream, StreamExt};
 use std::collections::{HashMap, HashSet, VecDeque};
 use std::ops::DerefMut;

subxt/src/backend/unstable/follow_stream_unpin.rs

@@ -9,6 +9,7 @@ use crate::backend::unstable::rpc_methods::{
 };
 use crate::config::{BlockHash, Config};
 use crate::error::Error;
+use crate::prelude::*;
 use futures::stream::{FuturesUnordered, Stream, StreamExt};
 use std::collections::{HashMap, HashSet};
 use std::future::Future;

subxt/src/backend/unstable/mod.rs

@@ -28,6 +28,7 @@ use crate::backend::{
 use crate::config::BlockHash;
 use crate::error::{Error, RpcError};
 use crate::Config;
+use crate::prelude::*;
 use async_trait::async_trait;
 use follow_stream_driver::{FollowStreamDriver, FollowStreamDriverHandle};
 use futures::{Stream, StreamExt};

subxt/src/backend/unstable/rpc_methods.rs

@@ -9,6 +9,7 @@
 use crate::backend::rpc::{rpc_params, RpcClient, RpcSubscription};
 use crate::config::BlockHash;
 use crate::{Config, Error};
+use crate::prelude::*;
 use derivative::Derivative;
 use futures::{Stream, StreamExt};
 use serde::{Deserialize, Serialize};

subxt/src/backend/unstable/storage_items.rs

@@ -9,6 +9,7 @@ use super::rpc_methods::{
 };
 use crate::config::Config;
 use crate::error::{Error, RpcError};
+use crate::prelude::*;
 use futures::{FutureExt, Stream, StreamExt};
 use std::collections::VecDeque;
 use std::future::Future;

subxt/src/blocks/block_types.rs

@@ -11,6 +11,7 @@ use crate::{
     events,
     runtime_api::RuntimeApi,
     storage::Storage,
+    prelude::*,
 };
 
 use codec::{Decode, Encode};

subxt/src/blocks/blocks_client.rs

@@ -9,6 +9,7 @@ use crate::{
     config::Config,
     error::{BlockError, Error},
     utils::PhantomDataSendSync,
+    prelude::*,
 };
 use derivative::Derivative;
 use futures::StreamExt;

subxt/src/blocks/extrinsic_types.rs

@@ -11,7 +11,7 @@ use crate::{
     metadata::types::PalletMetadata,
     Metadata,
 };
-
+use crate::prelude::*;
 use crate::config::signed_extensions::{
     ChargeAssetTxPayment, ChargeTransactionPayment, CheckNonce,
 };

subxt/src/client/light_client/builder.rs

@@ -8,6 +8,7 @@ use crate::client::RawLightClient;
 use crate::macros::{cfg_jsonrpsee_native, cfg_jsonrpsee_web};
 use crate::utils::validate_url_is_secure;
 use crate::{config::Config, error::Error, OnlineClient};
+use crate::prelude::*;
 use std::num::NonZeroU32;
 use subxt_lightclient::{smoldot, AddedChain};
 

subxt/src/client/light_client/mod.rs

@@ -20,6 +20,7 @@ use crate::{
     tx::TxClient,
     OnlineClient,
 };
+use crate::prelude::*;
 pub use builder::{LightClientBuilder, RawLightClientBuilder};
 use derivative::Derivative;
 use subxt_lightclient::LightClientRpcError;

subxt/src/client/light_client/rpc.rs

@@ -7,6 +7,7 @@ use crate::{
     backend::rpc::{RawRpcFuture, RawRpcSubscription, RpcClientT},
     error::{Error, RpcError},
 };
+use crate::prelude::*;
 use futures::StreamExt;
 use serde_json::value::RawValue;
 use tokio_stream::wrappers::UnboundedReceiverStream;

subxt/src/client/offline_client.rs

@@ -8,6 +8,7 @@ use crate::{
     events::EventsClient, runtime_api::RuntimeApiClient, storage::StorageClient, tx::TxClient,
     Config, Metadata,
 };
+use crate::prelude::*;
 use derivative::Derivative;
 
 use std::sync::Arc;

subxt/src/client/online_client.rs

@@ -17,6 +17,7 @@ use crate::{
     tx::TxClient,
     Config, Metadata,
 };
+use crate::prelude::*;
 use derivative::Derivative;
 use futures::future;
 use std::sync::{Arc, RwLock};

subxt/src/config/extrinsic_params.rs

@@ -8,6 +8,7 @@
 //! implementation of this that will work in many cases.
 
 use crate::{client::OfflineClientT, Config};
+use crate::prelude::*;
 use core::fmt::Debug;
 
 /// An error that can be emitted when trying to construct an instance of [`ExtrinsicParams`],

subxt/src/config/mod.rs

@@ -16,6 +16,7 @@ pub mod signed_extensions;
 pub mod substrate;
 
 use crate::macros::cfg_substrate_compat;
+use crate::prelude::*;
 use codec::{Decode, Encode};
 use core::fmt::Debug;
 use scale_decode::DecodeAsType;

subxt/src/config/signed_extensions.rs

@@ -10,6 +10,7 @@
 use super::extrinsic_params::{ExtrinsicParams, ExtrinsicParamsEncoder, ExtrinsicParamsError};
 use crate::utils::Era;
 use crate::{client::OfflineClientT, Config};
+use crate::prelude::*;
 use codec::{Compact, Encode};
 use core::fmt::Debug;
 use derivative::Derivative;

subxt/src/constants/constant_address.rs

@@ -3,6 +3,7 @@
 // see LICENSE for license details.
 
 use crate::{dynamic::DecodedValueThunk, metadata::DecodeWithMetadata};
+use crate::prelude::*;
 use derivative::Derivative;
 use std::borrow::Cow;
 

subxt/src/constants/constants_client.rs

@@ -9,6 +9,7 @@ use crate::{
     metadata::DecodeWithMetadata,
     Config,
 };
+use crate::prelude::*;
 use derivative::Derivative;
 
 /// A client for accessing constants.

subxt/src/custom_values/custom_value_address.rs

@@ -3,6 +3,7 @@ use std::marker::PhantomData;
 
 use crate::dynamic::DecodedValueThunk;
 use crate::metadata::DecodeWithMetadata;
+use crate::prelude::*;
 
 /// This represents the address of a custom value in in the metadata.
 /// Anything, that implements the [CustomValueAddress] trait can be used, to fetch

subxt/src/custom_values/custom_values_client.rs

@@ -3,6 +3,7 @@ use crate::custom_values::custom_value_address::{CustomValueAddress, Yes};
 use crate::error::MetadataError;
 use crate::metadata::DecodeWithMetadata;
 use crate::{Config, Error};
+use crate::prelude::*;
 use derivative::Derivative;
 
 /// A client for accessing custom values stored in the metadata.

subxt/src/dynamic.rs

@@ -10,7 +10,7 @@ use crate::{
     metadata::{DecodeWithMetadata, Metadata},
 };
 use scale_decode::DecodeAsType;
-
+use crate::prelude::*;
 pub use scale_value::{At, Value};
 
 /// A [`scale_value::Value`] type endowed with contextual information

subxt/src/error/dispatch_error.rs

@@ -9,6 +9,7 @@ use crate::metadata::{DecodeWithMetadata, Metadata};
 use core::fmt::Debug;
 use scale_decode::{visitor::DecodeAsTypeResult, DecodeAsType};
 use std::borrow::Cow;
+use crate::prelude::*;
 
 use super::{Error, MetadataError};
 

subxt/src/error/mod.rs

@@ -20,10 +20,12 @@ pub use dispatch_error::{
 // Re-expose the errors we use from other crates here:
 pub use crate::config::ExtrinsicParamsError;
 pub use crate::metadata::Metadata;
+use crate::prelude::*;
 pub use scale_decode::Error as DecodeError;
 pub use scale_encode::Error as EncodeError;
 pub use subxt_metadata::TryFromError as MetadataTryFromError;
 
+
 /// The underlying error enum, generic over the type held by the `Runtime`
 /// variant. Prefer to use the [`Error<E>`] and [`Error`] aliases over
 /// using this type directly.

subxt/src/events/events_client.rs

@@ -4,6 +4,7 @@
 
 use crate::backend::{Backend, BackendExt, BlockRef};
 use crate::{client::OnlineClientT, error::Error, events::Events, Config};
+use crate::prelude::*;
 use derivative::Derivative;
 use std::future::Future;
 

subxt/src/events/events_type.rs

@@ -12,6 +12,7 @@ use crate::{
     metadata::types::PalletMetadata,
     Config, Metadata,
 };
+use crate::prelude::*;
 use codec::{Compact, Decode};
 use derivative::Derivative;
 use scale_decode::DecodeAsType;

subxt/src/lib.rs

@@ -11,6 +11,7 @@
 //! Take a look at [the Subxt guide](book) to learn more about how to use Subxt.
 
 #![cfg_attr(docsrs, feature(doc_cfg))]
+#![cfg_attr(not(feature = "std"), no_std)]
 
 #[cfg(any(
     all(feature = "web", feature = "native"),
@@ -56,6 +57,7 @@ pub mod runtime_api;
 pub mod storage;
 pub mod tx;
 pub mod utils;
+pub mod prelude;
 
 // Internal helper macros
 #[macro_use]

subxt/src/metadata/decode_encode_traits.rs

@@ -4,6 +4,7 @@
 
 use super::Metadata;
 use crate::error::Error;
+use crate::prelude::*;
 
 /// This trait is implemented for all types that also implement [`scale_decode::DecodeAsType`].
 pub trait DecodeWithMetadata: Sized {

subxt/src/metadata/metadata_type.rs

@@ -3,7 +3,7 @@
 // see LICENSE for license details.
 
 use crate::error::MetadataError;
-
+use crate::prelude::*;
 use std::sync::Arc;
 
 /// A cheaply clone-able representation of the runtime metadata received from a node.

subxt/src/prelude.rs

@@ -0,0 +1,61 @@
+// Copyright 2019-2023 Parity Technologies (UK) Ltd.
+// This file is dual-licensed as Apache-2.0 or GPL-3.0.
+// see LICENSE for license details.
+
+//! Exports from `std`, `core` and `alloc` crates.
+//!
+//! Guarantees a stable interface between `std` and `no_std` modes.
+
+#[cfg(not(feature = "std"))]
+extern crate alloc;
+
+use cfg_if::cfg_if;
+
+cfg_if! {
+    if #[cfg(feature = "std")] {
+        pub use std::{
+            any,
+            borrow,
+            boxed::{Box},
+            cmp,
+            collections,
+            fmt,
+            format,
+            hash,
+            marker::{PhantomData},
+            mem,
+            num,
+            ops,
+            string,
+            sync,
+            time,
+            vec::{vec, Vec},
+            rc,
+            iter,
+        };
+    } else {
+        pub use alloc::{
+            borrow,
+            boxed::{Box},
+            collections,
+            format,
+            string,
+            sync,
+            vec::{vec, Vec},
+            rc
+        };
+
+        pub use core::{
+            any,
+            cmp,
+            fmt,
+            hash,
+            marker::{PhantomData},
+            mem,
+            num,
+            ops,
+            time,
+            iter,
+        };
+    }
+}

subxt/src/runtime_api/runtime_client.rs

@@ -5,6 +5,7 @@
 use super::runtime_types::RuntimeApi;
 
 use crate::{backend::BlockRef, client::OnlineClientT, error::Error, Config};
+use crate::prelude::*;
 use derivative::Derivative;
 use std::{future::Future, marker::PhantomData};
 

subxt/src/runtime_api/runtime_payload.rs

@@ -11,6 +11,7 @@ use std::borrow::Cow;
 use crate::dynamic::DecodedValueThunk;
 use crate::error::MetadataError;
 use crate::{metadata::DecodeWithMetadata, Error, Metadata};
+use crate::prelude::*;
 
 /// This represents a runtime API payload that can call into the runtime of node.
 ///

subxt/src/runtime_api/runtime_types.rs

@@ -9,6 +9,7 @@ use crate::{
     metadata::DecodeWithMetadata,
     Config,
 };
+use crate::prelude::*;
 use codec::Decode;
 use derivative::Derivative;
 use std::{future::Future, marker::PhantomData};

subxt/src/storage/storage_address.rs

@@ -8,6 +8,7 @@ use crate::{
     metadata::{DecodeWithMetadata, EncodeWithMetadata, Metadata},
     utils::{Encoded, Static},
 };
+use crate::prelude::*;
 use derivative::Derivative;
 use scale_info::TypeDef;
 use std::borrow::Cow;

subxt/src/storage/storage_client.rs

@@ -12,6 +12,7 @@ use crate::{
     error::Error,
     Config,
 };
+use crate::prelude::*;
 use derivative::Derivative;
 use std::{future::Future, marker::PhantomData};
 

subxt/src/storage/storage_type.rs

@@ -11,6 +11,7 @@ use crate::{
     metadata::{DecodeWithMetadata, Metadata},
     Config,
 };
+use crate::prelude::*;
 use codec::Decode;
 use derivative::Derivative;
 use futures::StreamExt;

subxt/src/storage/utils.rs

@@ -8,6 +8,7 @@
 
 use super::StorageAddress;
 use crate::{error::Error, metadata::Metadata};
+use crate::prelude::*;
 
 /// Return the root of a given [`StorageAddress`]: hash the pallet name and entry name
 /// and append those bytes to the output.

subxt/src/tx/tx_client.rs

@@ -9,9 +9,11 @@ use crate::{
     client::{OfflineClientT, OnlineClientT},
     config::{Config, ExtrinsicParams, ExtrinsicParamsEncoder, Hasher},
     error::{Error, MetadataError},
+    prelude::*,
     tx::{Signer as SignerT, TxPayload, TxProgress},
     utils::{Encoded, PhantomDataSendSync},
 };
+use crate::prelude::*;
 use codec::{Compact, Decode, Encode};
 use derivative::Derivative;
 use sp_core_hashing::blake2_256;

subxt/src/tx/tx_payload.rs

@@ -10,6 +10,7 @@ use crate::{
     error::{Error, MetadataError},
     metadata::Metadata,
 };
+use crate::prelude::*;
 use codec::Encode;
 use scale_encode::EncodeAsFields;
 use scale_value::{Composite, ValueDef, Variant};

subxt/src/tx/tx_progress.rs

@@ -14,6 +14,7 @@ use crate::{
     events::EventsClient,
     Config,
 };
+use crate::prelude::*;
 use derivative::Derivative;
 use futures::{Stream, StreamExt};
 

subxt/src/utils/mod.rs

@@ -15,6 +15,7 @@ mod wrapper_opaque;
 
 use crate::error::RpcError;
 use crate::Error;
+use crate::prelude::*;
 use codec::{Compact, Decode, Encode};
 use derivative::Derivative;
 use url::Url;

subxt/src/utils/wrapper_opaque.rs

@@ -153,7 +153,7 @@ impl<T> Visitor for WrapperKeepOpaqueVisitor<T> {
 impl<T> IntoVisitor for WrapperKeepOpaque<T> {
     type Visitor = WrapperKeepOpaqueVisitor<T>;
     fn into_visitor() -> Self::Visitor {
-        WrapperKeepOpaqueVisitor(std::marker::PhantomData)
+        WrapperKeepOpaqueVisitor(PhantomData)
     }
 }