Make subxt-core ready for publishing (#1508)

* Move Extrinsic decoding things to subxt_core and various tidy-ups

* A couple more fixes and fmt

* first pass moving tx logic to subxt_core

* cargo fmt

* fix wasm example

* clippy

* more clippy

* WIP Adding examples and such

* Move storage functionality more fully to subxt_core and nice examples for storage and txs

* Add example for events

* consistify how addresses/payloads are exposed in subxt-core and add runtime API fns

* Add runtime API core example

* fmt

* remove scale-info patch

* Add a little to the top level docs

* swap args around

* clippy

* cargo fmt and fix wasm-example

* doc fixes

* no-std-ise new subxt-core additions

* alloc, not core

* more no-std fixes

* A couple more fixes

* Add back extrinsic decode test

core/src/constants/mod.rs

@@ -1,29 +1,56 @@
-// Copyright 2019-2023 Parity Technologies (UK) Ltd.
+// Copyright 2019-2024 Parity Technologies (UK) Ltd.
 // This file is dual-licensed as Apache-2.0 or GPL-3.0.
 // see LICENSE for license details.
 
-//! Types associated with accessing constants.
+//! Access constants from metadata.
+//!
+//! Use [`get`] to retrieve a constant from some metadata, or [`validate`] to check that a static
+//! constant address lines up with the value seen in the metadata.
+//!
+//! # Example
+//!
+//! ```rust
+//! use subxt_macro::subxt;
+//! use subxt_core::constants;
+//! use subxt_core::metadata;
+//!
+//! // If we generate types without `subxt`, we need to point to `::subxt_core`:
+//! #[subxt(
+//!     crate = "::subxt_core",
+//!     runtime_metadata_path = "../artifacts/polkadot_metadata_small.scale",
+//! )]
+//! pub mod polkadot {}
+//!
+//! // Some metadata we'd like to access constants in:
+//! let metadata_bytes = include_bytes!("../../../artifacts/polkadot_metadata_small.scale");
+//! let metadata = metadata::decode_from(&metadata_bytes[..]).unwrap();
+//!
+//! // We can use a static address to obtain some constant:
+//! let address = polkadot::constants().balances().existential_deposit();
+//!
+//! // This validates that the address given is in line with the metadata
+//! // we're trying to access the constant in:
+//! constants::validate(&address, &metadata).expect("is valid");
+//!
+//! // This acquires the constant (and internally also validates it):
+//! let ed = constants::get(&address, &metadata).expect("can decode constant");
+//!
+//! assert_eq!(ed, 33_333_333);
+//! ```
 
-mod constant_address;
-
-pub use constant_address::{dynamic, Address, ConstantAddress, DynamicAddress};
+pub mod address;
 
+use address::AddressT;
 use alloc::borrow::ToOwned;
 
-use crate::{
-    error::MetadataError,
-    metadata::{DecodeWithMetadata, MetadataExt},
-    Error, Metadata,
-};
+use crate::{error::MetadataError, metadata::DecodeWithMetadata, Error, Metadata};
 
-/// Run validation logic against some constant address you'd like to access. Returns `Ok(())`
-/// if the address is valid (or if it's not possible to check since the address has no validation hash).
-/// Return an error if the address was not valid or something went wrong trying to validate it (ie
-/// the pallet or constant in question do not exist at all).
-pub fn validate_constant<Address: ConstantAddress>(
-    metadata: &subxt_metadata::Metadata,
-    address: &Address,
-) -> Result<(), Error> {
+/// When the provided `address` is statically generated via the `#[subxt]` macro, this validates
+/// that the shape of the constant value is the same as the shape expected by the static address.
+///
+/// When the provided `address` is dynamic (and thus does not come with any expectation of the
+/// shape of the constant value), this just returns `Ok(())`
+pub fn validate<Address: AddressT>(address: &Address, metadata: &Metadata) -> Result<(), Error> {
     if let Some(actual_hash) = address.validation_hash() {
         let expected_hash = metadata
             .pallet_by_name_err(address.pallet_name())?
@@ -38,12 +65,14 @@ pub fn validate_constant<Address: ConstantAddress>(
     Ok(())
 }
 
-pub fn get_constant<Address: ConstantAddress>(
-    metadata: &Metadata,
+/// Fetch a constant out of the metadata given a constant address. If the `address` has been
+/// statically generated, this will validate that the constant shape is as expected, too.
+pub fn get<Address: AddressT>(
     address: &Address,
+    metadata: &Metadata,
 ) -> Result<Address::Target, Error> {
     // 1. Validate constant shape if hash given:
-    validate_constant(metadata, address)?;
+    validate(address, metadata)?;
 
     // 2. Attempt to decode the constant into the type given:
     let constant = metadata