subxt-core crate (#1466)

* start migrating, broken * first iteration of updating * fmt and clippy * add Composite<u32> decoding via scale value patch * bump scale type gen versions * fix decoding with new scale decode * compiling with changed deps * core utils, condig, client, metadata * core crate compiling * signer crate no once lock * add core to no-std-tests, change imports * broken commit, start pulling everything together in subxt * port more things to subxt * events in core crate, extrinsics sadly much more difficult * almost all examples pass again * dynamic values fix in examples * fix no std issue and fmt * remove unused dependencies * fix lightclient impl * runtime version refactor * formatting and addressing nits * more comments addressed * update wasm example and no-std-signer tests * other nits and error impl on signer errors * fix feature flag * fix runtime version refactor * fix doc links * fix integration tests * fix feature flag gated client state * fix native feature in CI * fix lightclient utils * make imports more lean in subxt-core * integrate changes from subxt-core imports into subxt * other changes in subxt simplify imports more * fix and docs * doc false for cli * fix clippy * remove events block hash in tests * codegen no-std support in generated code * export alloc crate for no-std codegen * fix doc test * implement James comments * remove std traits, use core traits instead * address nits * remove unusued dep in no-std tests * fix Box import in no_std * sp-crypto-hashing instead of sp-core-hashing * bump scale-typegen, add no std codegen tests * fix some things * replace unmaintained derivative with derive_where to remove non-canonical warnings * fmt * remove unused dep * fix deps * update artifacts to fix type ID mismatches * bump to latest scale-typegen --------- Co-authored-by: James Wilson <james@jsdw.me>
2026-06-10 17:11:03 +00:00 · 2024-03-27 09:55:08 +01:00
parent 92c1ba7f66
commit a0cb14aa4f
106 changed files with 24329 additions and 26882 deletions
@@ -0,0 +1,180 @@
+// 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.
+
+//! This module contains the trait and types used to represent
+//! transactions that can be submitted.
+
+use crate::error::MetadataError;
+use crate::metadata::Metadata;
+use crate::Error;
+use alloc::borrow::{Cow, ToOwned};
+use alloc::string::String;
+
+use alloc::vec::Vec;
+use codec::Encode;
+use scale_encode::EncodeAsFields;
+use scale_value::{Composite, Value, ValueDef, Variant};
+
+pub mod signer;
+pub use signer::Signer;
+
+/// This represents a transaction payload that can be submitted
+/// to a node.
+pub trait TxPayload {
+    /// Encode call data to the provided output.
+    fn encode_call_data_to(&self, metadata: &Metadata, out: &mut Vec<u8>) -> Result<(), Error>;
+
+    /// Encode call data and return the output. This is a convenience
+    /// wrapper around [`TxPayload::encode_call_data_to`].
+    fn encode_call_data(&self, metadata: &Metadata) -> Result<Vec<u8>, Error> {
+        let mut v = Vec::new();
+        self.encode_call_data_to(metadata, &mut v)?;
+        Ok(v)
+    }
+
+    /// Returns the details needed to validate the call, which
+    /// include a statically generated hash, the pallet name,
+    /// and the call name.
+    fn validation_details(&self) -> Option<ValidationDetails<'_>> {
+        None
+    }
+}
+
+pub struct ValidationDetails<'a> {
+    /// The pallet name.
+    pub pallet_name: &'a str,
+    /// The call name.
+    pub call_name: &'a str,
+    /// A hash (this is generated at compile time in our codegen)
+    /// to compare against the runtime code.
+    pub hash: [u8; 32],
+}
+
+/// A transaction payload containing some generic `CallData`.
+#[derive(Clone, Debug, Eq, Ord, PartialEq, PartialOrd)]
+pub struct Payload<CallData> {
+    pallet_name: Cow<'static, str>,
+    call_name: Cow<'static, str>,
+    call_data: CallData,
+    validation_hash: Option<[u8; 32]>,
+}
+
+/// The type of a payload typically used for dynamic transaction payloads.
+pub type DynamicPayload = Payload<Composite<()>>;
+
+impl<CallData> Payload<CallData> {
+    /// Create a new [`Payload`].
+    pub fn new(
+        pallet_name: impl Into<String>,
+        call_name: impl Into<String>,
+        call_data: CallData,
+    ) -> Self {
+        Payload {
+            pallet_name: Cow::Owned(pallet_name.into()),
+            call_name: Cow::Owned(call_name.into()),
+            call_data,
+            validation_hash: None,
+        }
+    }
+
+    /// Create a new [`Payload`] using static strings for the pallet and call name.
+    /// This is only expected to be used from codegen.
+    #[doc(hidden)]
+    pub fn new_static(
+        pallet_name: &'static str,
+        call_name: &'static str,
+        call_data: CallData,
+        validation_hash: [u8; 32],
+    ) -> Self {
+        Payload {
+            pallet_name: Cow::Borrowed(pallet_name),
+            call_name: Cow::Borrowed(call_name),
+            call_data,
+            validation_hash: Some(validation_hash),
+        }
+    }
+
+    /// Do not validate this call prior to submitting it.
+    pub fn unvalidated(self) -> Self {
+        Self {
+            validation_hash: None,
+            ..self
+        }
+    }
+
+    /// Returns the call data.
+    pub fn call_data(&self) -> &CallData {
+        &self.call_data
+    }
+
+    /// Returns the pallet name.
+    pub fn pallet_name(&self) -> &str {
+        &self.pallet_name
+    }
+
+    /// Returns the call name.
+    pub fn call_name(&self) -> &str {
+        &self.call_name
+    }
+}
+
+impl Payload<Composite<()>> {
+    /// Convert the dynamic `Composite` payload into a [`Value`].
+    /// This is useful if you want to use this as an argument for a
+    /// larger dynamic call that wants to use this as a nested call.
+    pub fn into_value(self) -> Value<()> {
+        let call = Value {
+            context: (),
+            value: ValueDef::Variant(Variant {
+                name: self.call_name.into_owned(),
+                values: self.call_data,
+            }),
+        };
+
+        Value::unnamed_variant(self.pallet_name, [call])
+    }
+}
+
+impl<CallData: EncodeAsFields> TxPayload for Payload<CallData> {
+    fn encode_call_data_to(&self, metadata: &Metadata, out: &mut Vec<u8>) -> Result<(), Error> {
+        let pallet = metadata.pallet_by_name_err(&self.pallet_name)?;
+        let call = pallet
+            .call_variant_by_name(&self.call_name)
+            .ok_or_else(|| MetadataError::CallNameNotFound((*self.call_name).to_owned()))?;
+
+        let pallet_index = pallet.index();
+        let call_index = call.index;
+
+        pallet_index.encode_to(out);
+        call_index.encode_to(out);
+
+        let mut fields = call
+            .fields
+            .iter()
+            .map(|f| scale_encode::Field::new(&f.ty.id, f.name.as_deref()));
+
+        self.call_data
+            .encode_as_fields_to(&mut fields, metadata.types(), out)
+            .expect("The fields are valid types from the metadata, qed;");
+        Ok(())
+    }
+
+    fn validation_details(&self) -> Option<ValidationDetails<'_>> {
+        self.validation_hash.map(|hash| ValidationDetails {
+            pallet_name: &self.pallet_name,
+            call_name: &self.call_name,
+            hash,
+        })
+    }
+}
+
+/// Construct a transaction at runtime; essentially an alias to [`Payload::new()`]
+/// which provides a [`Composite`] value for the call data.
+pub fn dynamic(
+    pallet_name: impl Into<String>,
+    call_name: impl Into<String>,
+    call_data: impl Into<Composite<()>>,
+) -> DynamicPayload {
+    Payload::new(pallet_name, call_name, call_data.into())
+}
@@ -0,0 +1,100 @@
+// 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.
+
+//! A library to **sub**mit e**xt**rinsics to a
+//! [substrate](https://github.com/paritytech/substrate) node via RPC.
+
+use crate::macros::cfg_substrate_compat;
+use crate::Config;
+
+/// Signing transactions requires a [`Signer`]. This is responsible for
+/// providing the "from" account that the transaction is being signed by,
+/// as well as actually signing a SCALE encoded payload.
+pub trait Signer<T: Config> {
+    /// Return the "from" account ID.
+    fn account_id(&self) -> T::AccountId;
+
+    /// Return the "from" address.
+    fn address(&self) -> T::Address;
+
+    /// Takes a signer payload for an extrinsic, and returns a signature based on it.
+    ///
+    /// Some signers may fail, for instance because the hardware on which the keys are located has
+    /// refused the operation.
+    fn sign(&self, signer_payload: &[u8]) -> T::Signature;
+}
+
+cfg_substrate_compat! {
+    pub use pair_signer::PairSigner;
+}
+
+// A signer suitable for substrate based chains. This provides compatibility with Substrate
+// packages like sp_keyring and such, and so relies on sp_core and sp_runtime to be included.
+#[cfg(feature = "substrate-compat")]
+mod pair_signer {
+    use super::Signer;
+    use crate::Config;
+    use sp_core::Pair as PairT;
+    use sp_runtime::{
+        traits::{IdentifyAccount, Verify},
+        AccountId32 as SpAccountId32, MultiSignature as SpMultiSignature,
+    };
+
+    /// A [`Signer`] implementation that can be constructed from an [`sp_core::Pair`].
+    #[derive(Clone, Debug)]
+    pub struct PairSigner<T: Config, Pair> {
+        account_id: T::AccountId,
+        signer: Pair,
+    }
+
+    impl<T, Pair> PairSigner<T, Pair>
+    where
+        T: Config,
+        Pair: PairT,
+        // We go via an `sp_runtime::MultiSignature`. We can probably generalise this
+        // by implementing some of these traits on our built-in MultiSignature and then
+        // requiring them on all T::Signatures, to avoid any go-between.
+        <SpMultiSignature as Verify>::Signer: From<Pair::Public>,
+        T::AccountId: From<SpAccountId32>,
+    {
+        /// Creates a new [`Signer`] from an [`sp_core::Pair`].
+        pub fn new(signer: Pair) -> Self {
+            let account_id =
+                <SpMultiSignature as Verify>::Signer::from(signer.public()).into_account();
+            Self {
+                account_id: account_id.into(),
+                signer,
+            }
+        }
+
+        /// Returns the [`sp_core::Pair`] implementation used to construct this.
+        pub fn signer(&self) -> &Pair {
+            &self.signer
+        }
+
+        /// Return the account ID.
+        pub fn account_id(&self) -> &T::AccountId {
+            &self.account_id
+        }
+    }
+
+    impl<T, Pair> Signer<T> for PairSigner<T, Pair>
+    where
+        T: Config,
+        Pair: PairT,
+        Pair::Signature: Into<T::Signature>,
+    {
+        fn account_id(&self) -> T::AccountId {
+            self.account_id.clone()
+        }
+
+        fn address(&self) -> T::Address {
+            self.account_id.clone().into()
+        }
+
+        fn sign(&self, signer_payload: &[u8]) -> T::Signature {
+            self.signer.sign(signer_payload).into()
+        }
+    }
+}