Replace code with snippets

Author: 0xLucca

.snippets/code/develop/toolkit/api-libraries/subxt/subxt.rs

@@ -3,6 +3,10 @@ use subxt::utils::AccountId32;
 use subxt::{OnlineClient, PolkadotConfig};
 use subxt_signer::{bip39::Mnemonic,sr25519::Keypair};
 
+// Generate an interface that we can use from the node's metadata.
+#[subxt::subxt(runtime_metadata_path = "./polkadot_metadata.scale")]
+pub mod polkadot {}
+
 #[tokio::main(flavor = "current_thread")]
 async fn main() -> Result<(), Box<dyn std::error::Error>> {
     // Define the node URL.

develop/toolkit/api-libraries/subxt.md

@@ -56,15 +56,7 @@ These dependencies are essential for interacting with the blockchain:
 After adding the dependencies, your `Cargo.toml` should look like this:
 
 ```toml
-[package]
-name = "my_project"
-version = "0.1.0"
-edition = "2021"
-
-[dependencies]
-subxt = "0.39.0"
-subxt-signer = "0.39.0"
-tokio = { version = "1.43.0", features = ["rt", "macros"] }
+--8<-- 'code/develop/toolkit/api-libraries/subxt/Cargo.toml'
 ```
 
 ## Get Started
@@ -84,33 +76,28 @@ subxt metadata --url INSERT_NODE_URL > polkadot_metadata.scale
 Use the `#[subxt::subxt]` macro to generate a type-safe Rust interface from the downloaded metadata:
 
 ```rust
-// Generate an interface that we can use from the node's metadata.
-#[subxt::subxt(runtime_metadata_path = "./polkadot_metadata.scale")]
-pub mod polkadot {}
+--8<-- 'code/develop/toolkit/api-libraries/subxt/subxt.rs:6:8'
 ```
 
+Once subxt interfaces are generated, you can interact with your node in the following ways:
+
+- **Transactions** - builds and submits transactions, monitors their inclusion in blocks, and retrieves associated events
+- **Storage** - enables querying of node storage data
+- **Events** - retrieves events emitted from recent blocks
+- **Constants** - accesses constant values stored in nodes that remain unchanged across a specific runtime version.
+- **Blocks** - loads recent blocks or subscribes to new/finalized blocks, allowing examination of extrinsics, events, and storage at those blocks
+- **Runtime APIs** - makes calls into pallet runtime APIs to fetch data
+- **Custom values** - accesses "custom values" contained within metadata
+- **Raw RPC calls** - facilitates raw RPC requests to compatible nodes
+
 ### Initializing the Subxt client
 
 To interact with a blockchain node using Subxt, create an asynchronous main function and initialize the client. Replace `INSERT_NODE_URL` with the URL of your target node:
 
 ```rust
-use std::str::FromStr;
-use subxt::utils::AccountId32;
-use subxt::{OnlineClient, PolkadotConfig};
-use subxt_signer::{bip39::Mnemonic,sr25519::Keypair};
-
-#[tokio::main(flavor = "current_thread")]
-async fn main() -> Result<(), Box<dyn std::error::Error>> {
-    // Define the node URL.
-    const NODE_URL: &str = "INSERT_NODE_URL";
-
-    // Initialize the Subxt client for interacting with the blockchain.
-    let api = OnlineClient::<PolkadotConfig>::from_url(NODE_URL).await?;
-
+--8<-- 'code/develop/toolkit/api-libraries/subxt/subxt.rs::17'
     // Your code here...
-
-    Ok(())
-}
+--8<-- 'code/develop/toolkit/api-libraries/subxt/subxt.rs:73:75'
 ```
 
 ### Reading Chain Data
@@ -120,35 +107,17 @@ Subxt provides multiple ways to access on-chain data:
 - Constants - constants are predefined values in the runtime that remain unchanged unless modified by a runtime upgrade
 
     For example, to retrieve the existential deposit, use:
+    
     ```rust
-    // A query to obtain some contant:
-    let constant_query = polkadot::constants().balances().existential_deposit();
-
-    // Obtain the value:
-    let value = api.constants().at(&constant_query)?;
+    --8<-- 'code/develop/toolkit/api-libraries/subxt/subxt.rs:18:24'
     ```
 
 - State - state refers to the current chain data, which updates with each block
 
     To fetch account information, use:
+
     ```rust
-    // Define the target account address.
-    const ADDRESS: &str = "INSERT_ADDRESS";
-    let account = AccountId32::from_str(ADDRESS).unwrap();
-
-    // Build a storage query to access account information.
-    let storage_query = polkadot::storage().system().account(&account.into());
-
-    // Fetch the latest state for the account.
-    let result = api
-        .storage()
-        .at_latest()
-        .await?
-        .fetch(&storage_query)
-        .await?
-        .unwrap();
-
-    println!("Account info: {:?}", result);
+    --8<-- 'code/develop/toolkit/api-libraries/subxt/subxt.rs:26:42'
     ```
 
 ### Submitting Transasctions
@@ -158,35 +127,7 @@ To submit a transaction, you need to construct an extrinsic, sign it with your p
 For example, to transfer funds to another account:
 
 ```rust
-// Define the recipient address and transfer amount.
-const DEST_ADDRESS: &str = "INSERT_DEST_ADDRESS";
-const AMOUNT: u128 = INSERT_AMOUNT;
-
-// Convert the recipient address into an `AccountId32`.
-let dest = AccountId32::from_str(DEST_ADDRESS).unwrap();
-
-// Build the balance transfer extrinsic.
-let balance_transfer_tx = polkadot::tx()
-    .balances()
-    .transfer_allow_death(dest.into(), AMOUNT);
-
-// Load the sender's keypair from a mnemonic phrase.
-const SECRET_PHRASE: &str = "INSERT_SECRET_PHRASE";
-let mnemonic = Mnemonic::parse(SECRET_PHRASE).unwrap();
-let sender_keypair = Keypair::from_phrase(&mnemonic, None).unwrap();
-
-// Sign and submit the extrinsic, then wait for it to be finalized.
-let events = api
-    .tx()
-    .sign_and_submit_then_watch_default(&balance_transfer_tx, &sender_keypair)
-    .await?
-    .wait_for_finalized_success()
-    .await?;
-
-// Check for a successful transfer event.
-if let Some(event) = events.find_first::<polkadot::balances::events::Transfer>()? {
-    println!("Balance transfer successful: {:?}", event);
-}
+--8<-- 'code/develop/toolkit/api-libraries/subxt/subxt.rs:44:72'
 ```
 
 ## Where to Go Next

llms.txt

@@ -7823,7 +7823,7 @@ After adding the dependencies, your `Cargo.toml` should look like this:
 
 ```toml
 [package]
-name = "my_project"
+name = "my-project"
 version = "0.1.0"
 edition = "2021"
 
@@ -7850,11 +7850,21 @@ subxt metadata --url INSERT_NODE_URL > polkadot_metadata.scale
 Use the `#[subxt::subxt]` macro to generate a type-safe Rust interface from the downloaded metadata:
 
 ```rust
-// Generate an interface that we can use from the node's metadata.
 #[subxt::subxt(runtime_metadata_path = "./polkadot_metadata.scale")]
 pub mod polkadot {}
 ```
 
+Once subxt interfaces are generated, you can interact with your node in the following ways:
+
+- **Transactions** - builds and submits transactions, monitors their inclusion in blocks, and retrieves associated events
+- **Storage** - enables querying of node storage data
+- **Events** - retrieves events emitted from recent blocks
+- **Constants** - accesses constant values stored in nodes that remain unchanged across a specific runtime version.
+- **Blocks** - loads recent blocks or subscribes to new/finalized blocks, allowing examination of extrinsics, events, and storage at those blocks
+- **Runtime APIs** - makes calls into pallet runtime APIs to fetch data
+- **Custom values** - accesses "custom values" contained within metadata
+- **Raw RPC calls** - facilitates raw RPC requests to compatible nodes
+
 ### Initializing the Subxt client
 
 To interact with a blockchain node using Subxt, create an asynchronous main function and initialize the client. Replace `INSERT_NODE_URL` with the URL of your target node:
@@ -7865,6 +7875,10 @@ use subxt::utils::AccountId32;
 use subxt::{OnlineClient, PolkadotConfig};
 use subxt_signer::{bip39::Mnemonic,sr25519::Keypair};
 
+// Generate an interface that we can use from the node's metadata.
+#[subxt::subxt(runtime_metadata_path = "./polkadot_metadata.scale")]
+pub mod polkadot {}
+
 #[tokio::main(flavor = "current_thread")]
 async fn main() -> Result<(), Box<dyn std::error::Error>> {
     // Define the node URL.
@@ -7873,9 +7887,66 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
     // Initialize the Subxt client for interacting with the blockchain.
     let api = OnlineClient::<PolkadotConfig>::from_url(NODE_URL).await?;
 
-    // Your code here...
+    // A query to obtain some contant:
+    let constant_query = polkadot::constants().balances().existential_deposit();
+
+    // Obtain the value:
+    let value = api.constants().at(&constant_query)?;
+
+    println!("Existential deposit: {:?}", value);
+
+    // Define the target account address.
+    const ADDRESS: &str = "INSERT_ADDRESS";
+    let account = AccountId32::from_str(ADDRESS).unwrap();
+
+    // Build a storage query to access account information.
+    let storage_query = polkadot::storage().system().account(&account.into());
+
+    // Fetch the latest state for the account.
+    let result = api
+        .storage()
+        .at_latest()
+        .await?
+        .fetch(&storage_query)
+        .await?
+        .unwrap();
+
+    println!("Account info: {:?}", result);
+
+    // Define the recipient address and transfer amount.
+    const DEST_ADDRESS: &str = "INSERT_DEST_ADDRESS";
+    const AMOUNT: u128 = INSERT_AMOUNT;
+
+    // Convert the recipient address into an `AccountId32`.
+    let dest = AccountId32::from_str(DEST_ADDRESS).unwrap();
+
+    // Build the balance transfer extrinsic.
+    let balance_transfer_tx = polkadot::tx()
+        .balances()
+        .transfer_allow_death(dest.into(), AMOUNT);
+
+    // Load the sender's keypair from a mnemonic phrase.
+    const SECRET_PHRASE: &str = "INSERT_SECRET_PHRASE";
+    let mnemonic = Mnemonic::parse(SECRET_PHRASE).unwrap();
+    let sender_keypair = Keypair::from_phrase(&mnemonic, None).unwrap();
+
+    // Sign and submit the extrinsic, then wait for it to be finalized.
+    let events = api
+        .tx()
+        .sign_and_submit_then_watch_default(&balance_transfer_tx, &sender_keypair)
+        .await?
+        .wait_for_finalized_success()
+        .await?;
+
+    // Check for a successful transfer event.
+    if let Some(event) = events.find_first::<polkadot::balances::events::Transfer>()? {
+        println!("Balance transfer successful: {:?}", event);
+    }
 
     Ok(())
+}
+    // Your code here...
+Ok(())
 }
 ```
 
@@ -7886,19 +7957,21 @@ Subxt provides multiple ways to access on-chain data:
 - Constants - constants are predefined values in the runtime that remain unchanged unless modified by a runtime upgrade
 
     For example, to retrieve the existential deposit, use:
+    
     ```rust
-    // A query to obtain some contant:
     let constant_query = polkadot::constants().balances().existential_deposit();
 
     // Obtain the value:
     let value = api.constants().at(&constant_query)?;
+
+    println!("Existential deposit: {:?}", value);
     ```
 
 - State - state refers to the current chain data, which updates with each block
 
     To fetch account information, use:
+
     ```rust
-    // Define the target account address.
     const ADDRESS: &str = "INSERT_ADDRESS";
     let account = AccountId32::from_str(ADDRESS).unwrap();
 
@@ -7924,35 +7997,34 @@ To submit a transaction, you need to construct an extrinsic, sign it with your p
 For example, to transfer funds to another account:
 
 ```rust
-// Define the recipient address and transfer amount.
 const DEST_ADDRESS: &str = "INSERT_DEST_ADDRESS";
-const AMOUNT: u128 = INSERT_AMOUNT;
-
-// Convert the recipient address into an `AccountId32`.
-let dest = AccountId32::from_str(DEST_ADDRESS).unwrap();
-
-// Build the balance transfer extrinsic.
-let balance_transfer_tx = polkadot::tx()
-    .balances()
-    .transfer_allow_death(dest.into(), AMOUNT);
-
-// Load the sender's keypair from a mnemonic phrase.
-const SECRET_PHRASE: &str = "INSERT_SECRET_PHRASE";
-let mnemonic = Mnemonic::parse(SECRET_PHRASE).unwrap();
-let sender_keypair = Keypair::from_phrase(&mnemonic, None).unwrap();
-
-// Sign and submit the extrinsic, then wait for it to be finalized.
-let events = api
-    .tx()
-    .sign_and_submit_then_watch_default(&balance_transfer_tx, &sender_keypair)
-    .await?
-    .wait_for_finalized_success()
-    .await?;
-
-// Check for a successful transfer event.
-if let Some(event) = events.find_first::<polkadot::balances::events::Transfer>()? {
-    println!("Balance transfer successful: {:?}", event);
-}
+    const AMOUNT: u128 = INSERT_AMOUNT;
+
+    // Convert the recipient address into an `AccountId32`.
+    let dest = AccountId32::from_str(DEST_ADDRESS).unwrap();
+
+    // Build the balance transfer extrinsic.
+    let balance_transfer_tx = polkadot::tx()
+        .balances()
+        .transfer_allow_death(dest.into(), AMOUNT);
+
+    // Load the sender's keypair from a mnemonic phrase.
+    const SECRET_PHRASE: &str = "INSERT_SECRET_PHRASE";
+    let mnemonic = Mnemonic::parse(SECRET_PHRASE).unwrap();
+    let sender_keypair = Keypair::from_phrase(&mnemonic, None).unwrap();
+
+    // Sign and submit the extrinsic, then wait for it to be finalized.
+    let events = api
+        .tx()
+        .sign_and_submit_then_watch_default(&balance_transfer_tx, &sender_keypair)
+        .await?
+        .wait_for_finalized_success()
+        .await?;
+
+    // Check for a successful transfer event.
+    if let Some(event) = events.find_first::<polkadot::balances::events::Transfer>()? {
+        println!("Balance transfer successful: {:?}", event);
+    }
 ```
 
 ## Where to Go Next