Merge remote-tracking branch 'origin/master' into lexnv/codegen-config

subxt/examples/reconnecting_rpc_client.rs

@@ -1,73 +0,0 @@
-//! Example to utilize the `reconnecting rpc client` in subxt
-//! which hidden behind behind `--feature unstable-reconnecting-rpc-client`
-//!
-//! To utilize full logs from the RPC client use:
-//! `RUST_LOG="jsonrpsee=trace,reconnecting_jsonrpsee_ws_client=trace"`
-
-#![allow(missing_docs)]
-
-use std::time::Duration;
-
-use subxt::backend::rpc::reconnecting_rpc_client::{Client, ExponentialBackoff, PingConfig};
-use subxt::backend::rpc::RpcClient;
-use subxt::error::{Error, RpcError};
-use subxt::{OnlineClient, PolkadotConfig};
-
-// Generate an interface that we can use from the node's metadata.
-#[subxt::subxt(runtime_metadata_path = "../artifacts/polkadot_metadata_small.scale")]
-pub mod polkadot {}
-
-#[tokio::main]
-async fn main() -> Result<(), Box<dyn std::error::Error>> {
-    tracing_subscriber::fmt::init();
-
-    // Create a new client with with a reconnecting RPC client.
-    let rpc = Client::builder()
-        // Reconnect with exponential backoff
-        //
-        // This API is "iterator-like" so one could limit it to only
-        // reconnect x times and then quit.
-        .retry_policy(ExponentialBackoff::from_millis(100).max_delay(Duration::from_secs(10)))
-        // Send period WebSocket pings/pongs every 6th second and if it's not ACK:ed in 30 seconds
-        // then disconnect.
-        //
-        // This is just a way to ensure that the connection isn't idle if no message is sent that often
-        .enable_ws_ping(
-            PingConfig::new()
-                .ping_interval(Duration::from_secs(6))
-                .inactive_limit(Duration::from_secs(30)),
-        )
-        // There are other configurations as well that can be found here:
-        // <https://docs.rs/reconnecting-jsonrpsee-ws-client/latest/reconnecting_jsonrpsee_ws_client/struct.ClientBuilder.html>
-        .build("ws://localhost:9944".to_string())
-        .await?;
-
-    let api: OnlineClient<PolkadotConfig> =
-        OnlineClient::from_rpc_client(RpcClient::new(rpc.clone())).await?;
-
-    // Subscribe to all finalized blocks:
-    let mut blocks_sub = api.blocks().subscribe_finalized().await?;
-
-    // For each block, print a bunch of information about it:
-    while let Some(block) = blocks_sub.next().await {
-        let block = match block {
-            Ok(b) => b,
-            Err(Error::Rpc(RpcError::DisconnectedWillReconnect(err))) => {
-                println!("{err}");
-                continue;
-            }
-            Err(e) => {
-                return Err(e.into());
-            }
-        };
-
-        let block_number = block.header().number;
-        let block_hash = block.hash();
-
-        println!("Block #{block_number} ({block_hash})");
-    }
-
-    println!("RPC client reconnected `{}` times", rpc.reconnect_count());
-
-    Ok(())
-}

subxt/examples/setup_config_signed_extension.rs

@@ -37,6 +37,7 @@ impl Config for CustomConfig {
             signed_extensions::CheckMortality<Self>,
             signed_extensions::ChargeAssetTxPayment<Self>,
             signed_extensions::ChargeTransactionPayment,
+            signed_extensions::CheckMetadataHash,
             // And add a new one of our own:
             CustomSignedExtension,
         ),
@@ -83,8 +84,8 @@ impl ExtrinsicParamsEncoder for CustomSignedExtension {
 pub fn custom(
     params: DefaultExtrinsicParamsBuilder<CustomConfig>,
 ) -> <<CustomConfig as Config>::ExtrinsicParams as ExtrinsicParams<CustomConfig>>::Params {
-    let (a, b, c, d, e, f, g) = params.build();
-    (a, b, c, d, e, f, g, ())
+    let (a, b, c, d, e, f, g, h) = params.build();
+    (a, b, c, d, e, f, g, h, ())
 }
 
 #[tokio::main]

subxt/examples/setup_reconnecting_rpc_client.rs

@@ -0,0 +1,84 @@
+//! Example to utilize the `reconnecting rpc client` in subxt
+//! which hidden behind behind `--feature unstable-reconnecting-rpc-client`
+//!
+//! To utilize full logs from the RPC client use:
+//! `RUST_LOG="jsonrpsee=trace,subxt-reconnecting-rpc-client=trace"`
+
+#![allow(missing_docs)]
+
+use std::time::Duration;
+
+use futures::StreamExt;
+use subxt::backend::rpc::reconnecting_rpc_client::{ExponentialBackoff, RpcClient};
+use subxt::{OnlineClient, PolkadotConfig};
+
+// Generate an interface that we can use from the node's metadata.
+#[subxt::subxt(runtime_metadata_path = "../artifacts/polkadot_metadata_small.scale")]
+pub mod polkadot {}
+
+#[tokio::main]
+async fn main() -> Result<(), Box<dyn std::error::Error>> {
+    tracing_subscriber::fmt::init();
+
+    // Create a new client with with a reconnecting RPC client.
+    let rpc = RpcClient::builder()
+        // Reconnect with exponential backoff
+        //
+        // This API is "iterator-like" and we use `take` to limit the number of retries.
+        .retry_policy(
+            ExponentialBackoff::from_millis(100)
+                .max_delay(Duration::from_secs(10))
+                .take(3),
+        )
+        // There are other configurations as well that can be found at [`reconnecting_rpc_client::ClientBuilder`].
+        .build("ws://localhost:9944".to_string())
+        .await?;
+
+    // If you want to use the unstable backend with the reconnecting RPC client, you can do so like this:
+    //
+    // ```
+    // use subxt::backend::unstable::UnstableBackend;
+    // use subxt::OnlineClient;
+    //
+    // let (backend, mut driver) = UnstableBackend::builder().build(RpcClient::new(rpc.clone()));
+    // tokio::spawn(async move {
+    //     while let Some(val) = driver.next().await {
+    //         if let Err(e) = val {
+    //             eprintln!("Error driving unstable backend: {e}; terminating client");
+    //        }
+    //    }
+    // });
+    // let api: OnlineClient<PolkadotConfig> = OnlineClient::from_backend(Arc::new(backend)).await?;
+    // ```
+
+    let api: OnlineClient<PolkadotConfig> = OnlineClient::from_rpc_client(rpc.clone()).await?;
+
+    // Run for at most 100 blocks and print a bunch of information about it.
+    //
+    // The subscription is automatically re-started when the RPC client has reconnected.
+    // You can test that by stopping the polkadot node and restarting it.
+    let mut blocks_sub = api.blocks().subscribe_finalized().await?.take(100);
+
+    while let Some(block) = blocks_sub.next().await {
+        let block = match block {
+            Ok(b) => b,
+            Err(e) => {
+                // This can only happen on the legacy backend and the unstable backend
+                // will handle this internally.
+                if e.is_disconnected_will_reconnect() {
+                    println!("The RPC connection was lost and we may have missed a few blocks");
+                    continue;
+                }
+
+                return Err(e.into());
+            }
+        };
+
+        let block_number = block.number();
+        let block_hash = block.hash();
+
+        println!("Block #{block_number} ({block_hash})");
+    }
+
+    Ok(())
+}

subxt/examples/storage_fetch.rs

@@ -22,10 +22,10 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
         .storage()
         .at_latest()
         .await?
-        .fetch_raw(subxt_core::storage::get_address_bytes(&storage_query, &api.metadata()).unwrap())
+        .fetch(&storage_query)
         .await?;
 
-    let v = hex::encode(result.unwrap());
+    let v = result.unwrap().data.free;
     println!("Alice: {v}");
     Ok(())
 }

subxt/examples/tx_basic_frontier.rs

@@ -6,7 +6,8 @@
 #![allow(missing_docs)]
 
 use subxt::OnlineClient;
-use subxt_signer::eth::{dev, AccountId20, Signature};
+use subxt_core::utils::AccountId20;
+use subxt_signer::eth::{dev, Signature};
 
 #[subxt::subxt(runtime_metadata_path = "../artifacts/frontier_metadata_small.scale")]
 mod eth_runtime {}
@@ -25,28 +26,20 @@ impl subxt::Config for EthRuntimeConfig {
     type AssetId = u32;
 }
 
-// This helper makes it easy to use our `AccountId20`'s with generated
-// code that expects a generated `eth_runtime::runtime_types::fp_account:AccountId20` type.
-impl From<AccountId20> for eth_runtime::runtime_types::fp_account::AccountId20 {
-    fn from(a: AccountId20) -> Self {
-        eth_runtime::runtime_types::fp_account::AccountId20(a.0)
-    }
-}
-
 #[tokio::main]
 async fn main() -> Result<(), Box<dyn std::error::Error>> {
     let api = OnlineClient::<EthRuntimeConfig>::from_insecure_url("ws://127.0.0.1:9944").await?;
 
     let alith = dev::alith();
     let baltathar = dev::baltathar();
-    let dest = baltathar.account_id();
+    let dest = baltathar.public_key().to_account_id();
 
     println!("baltathar pub:  {}", hex::encode(baltathar.public_key().0));
     println!("baltathar addr: {}", hex::encode(dest));
 
     let balance_transfer_tx = eth_runtime::tx()
         .balances()
-        .transfer_allow_death(dest.into(), 10_001);
+        .transfer_allow_death(dest, 10_001);
 
     let events = api
         .tx()

subxt/examples/tx_boxed.rs

@@ -0,0 +1,43 @@
+#![allow(missing_docs)]
+use subxt::{OnlineClient, PolkadotConfig};
+use subxt_signer::sr25519::dev;
+
+#[subxt::subxt(runtime_metadata_path = "../artifacts/polkadot_metadata_small.scale")]
+pub mod polkadot {}
+
+#[tokio::main]
+async fn main() -> Result<(), Box<dyn std::error::Error>> {
+    let api = OnlineClient::<PolkadotConfig>::new().await?;
+
+    // Prepare some extrinsics. These are boxed so that they can live alongside each other.
+    let txs = [dynamic_remark(), balance_transfer(), remark()];
+
+    for tx in txs {
+        let from = dev::alice();
+        api.tx()
+            .sign_and_submit_then_watch_default(&tx, &from)
+            .await?
+            .wait_for_finalized_success()
+            .await?;
+
+        println!("Submitted tx");
+    }
+
+    Ok(())
+}
+
+fn balance_transfer() -> Box<dyn subxt::tx::Payload> {
+    let dest = dev::bob().public_key().into();
+    Box::new(polkadot::tx().balances().transfer_allow_death(dest, 10_000))
+}
+
+fn remark() -> Box<dyn subxt::tx::Payload> {
+    Box::new(polkadot::tx().system().remark(vec![1, 2, 3, 4, 5]))
+}
+
+fn dynamic_remark() -> Box<dyn subxt::tx::Payload> {
+    use subxt::dynamic::{tx, Value};
+    let tx_payload = tx("System", "remark", vec![Value::from_bytes("Hello")]);
+
+    Box::new(tx_payload)
+}

subxt/examples/tx_partial.rs

@@ -0,0 +1,53 @@
+#![allow(missing_docs)]
+use subxt::{OnlineClient, PolkadotConfig};
+use subxt_signer::sr25519::dev;
+
+type BoxedError = Box<dyn std::error::Error + Send + Sync + 'static>;
+
+#[subxt::subxt(runtime_metadata_path = "../artifacts/polkadot_metadata_small.scale")]
+pub mod polkadot {}
+
+#[tokio::main]
+async fn main() -> Result<(), BoxedError> {
+    // Spawned tasks require things held across await points to impl Send,
+    // so we use one to demonstrate that this is possible with `PartialExtrinsic`
+    tokio::spawn(signing_example()).await??;
+    Ok(())
+}
+
+async fn signing_example() -> Result<(), BoxedError> {
+    let api = OnlineClient::<PolkadotConfig>::new().await?;
+
+    // Build a balance transfer extrinsic.
+    let dest = dev::bob().public_key().into();
+    let balance_transfer_tx = polkadot::tx().balances().transfer_allow_death(dest, 10_000);
+
+    let alice = dev::alice();
+
+    // Create partial tx, ready to be signed.
+    let partial_tx = api
+        .tx()
+        .create_partial_signed(
+            &balance_transfer_tx,
+            &alice.public_key().to_account_id(),
+            Default::default(),
+        )
+        .await?;
+
+    // Simulate taking some time to get a signature back, in part to
+    // show that the `PartialExtrinsic` can be held across await points.
+    tokio::time::sleep(tokio::time::Duration::from_millis(100)).await;
+    let signature = alice.sign(&partial_tx.signer_payload());
+
+    // Sign the transaction.
+    let tx = partial_tx
+        .sign_with_address_and_signature(&alice.public_key().to_address(), &signature.into());
+
+    // Submit it.
+    tx.submit_and_watch()
+        .await?
+        .wait_for_finalized_success()
+        .await?;
+
+    Ok(())
+}