352 lines
17 KiB
Rust
352 lines
17 KiB
Rust
//! XCM Reserve Transfer Test - Comprehensive
|
|
//!
|
|
//! This example performs a complete XCM reserve transfer from Relay Chain
|
|
//! to Asset Hub teyrchain and verifies the transfer was successful.
|
|
//!
|
|
//! Test Flow:
|
|
//! 1. Connect to both Relay Chain and Asset Hub
|
|
//! 2. Query Alice's balance on both chains (before)
|
|
//! 3. Execute XCM transfer_assets from Relay to Asset Hub
|
|
//! 4. Wait for XCM message to be processed
|
|
//! 5. Query Alice's balance on both chains (after)
|
|
//! 6. Verify the transfer amounts match
|
|
//!
|
|
//! Run with: cargo run --example xcm_reserve_transfer
|
|
|
|
#![allow(missing_docs)]
|
|
use pezkuwi_subxt::dynamic::{At, Value};
|
|
use pezkuwi_subxt::utils::AccountId32;
|
|
use pezkuwi_subxt::{OnlineClient, PezkuwiConfig};
|
|
use pezkuwi_subxt_signer::sr25519::dev;
|
|
use std::time::Duration;
|
|
|
|
// Generate interface from Pezkuwichain relay chain metadata
|
|
#[pezkuwi_subxt::subxt(runtime_metadata_path = "../artifacts/pezkuwichain_metadata.scale")]
|
|
pub mod relay {}
|
|
|
|
// Generate interface from Asset Hub metadata
|
|
#[pezkuwi_subxt::subxt(runtime_metadata_path = "../artifacts/asset_hub_metadata.scale")]
|
|
pub mod asset_hub {}
|
|
|
|
const RELAY_RPC: &str = "ws://127.0.0.1:9944";
|
|
const ASSET_HUB_RPC: &str = "ws://127.0.0.1:9945";
|
|
const ASSET_HUB_PARA_ID: u32 = 1000;
|
|
|
|
// 1 HEZ = 10^12 TYR (planck units)
|
|
const PLANCKS_PER_HEZ: u128 = 1_000_000_000_000;
|
|
|
|
/// Query balance from relay chain using dynamic storage query
|
|
async fn query_relay_balance(
|
|
api: &OnlineClient<PezkuwiConfig>,
|
|
account: &AccountId32,
|
|
) -> Result<u128, Box<dyn std::error::Error>> {
|
|
let storage = api.storage().at_latest().await?;
|
|
|
|
// Use dynamic storage query for flexibility
|
|
let storage_query =
|
|
pezkuwi_subxt::dynamic::storage::<(AccountId32,), Value>("System", "Account");
|
|
|
|
let account_info = storage.entry(storage_query)?.fetch((account.clone(),)).await?.decode()?;
|
|
|
|
// Extract the free balance using the At trait
|
|
let free_balance = account_info
|
|
.at("data")
|
|
.at("free")
|
|
.ok_or("Could not find free balance")?
|
|
.as_u128()
|
|
.ok_or("Could not parse free balance as u128")?;
|
|
|
|
Ok(free_balance)
|
|
}
|
|
|
|
/// Query balance from Asset Hub using dynamic storage query
|
|
async fn query_asset_hub_balance(
|
|
api: &OnlineClient<PezkuwiConfig>,
|
|
account: &AccountId32,
|
|
) -> Result<u128, Box<dyn std::error::Error>> {
|
|
let storage = api.storage().at_latest().await?;
|
|
|
|
// Use dynamic storage query for flexibility
|
|
let storage_query =
|
|
pezkuwi_subxt::dynamic::storage::<(AccountId32,), Value>("System", "Account");
|
|
|
|
let account_info = storage.entry(storage_query)?.fetch((account.clone(),)).await?.decode()?;
|
|
|
|
// Extract the free balance using the At trait
|
|
let free_balance = account_info
|
|
.at("data")
|
|
.at("free")
|
|
.ok_or("Could not find free balance")?
|
|
.as_u128()
|
|
.ok_or("Could not parse free balance as u128")?;
|
|
|
|
Ok(free_balance)
|
|
}
|
|
|
|
#[tokio::main]
|
|
async fn main() -> Result<(), Box<dyn std::error::Error>> {
|
|
println!("╔══════════════════════════════════════════════════════════════╗");
|
|
println!("║ XCM RESERVE TRANSFER TEST - PEZKUWICHAIN ║");
|
|
println!("╠══════════════════════════════════════════════════════════════╣");
|
|
println!("║ From: Relay Chain (HEZ) ║");
|
|
println!("║ To: Asset Hub Teyrchain (Para {}) ║", ASSET_HUB_PARA_ID);
|
|
println!("╚══════════════════════════════════════════════════════════════╝\n");
|
|
|
|
// ═══════════════════════════════════════════════════════════════════════
|
|
// STEP 1: Connect to both chains
|
|
// ═══════════════════════════════════════════════════════════════════════
|
|
println!("═══ STEP 1: Connecting to chains ═══");
|
|
|
|
let relay_api = OnlineClient::<PezkuwiConfig>::from_url(RELAY_RPC).await?;
|
|
println!("✓ Connected to Relay Chain at {}", RELAY_RPC);
|
|
|
|
let asset_hub_api = OnlineClient::<PezkuwiConfig>::from_url(ASSET_HUB_RPC).await?;
|
|
println!("✓ Connected to Asset Hub at {}", ASSET_HUB_RPC);
|
|
|
|
// ═══════════════════════════════════════════════════════════════════════
|
|
// STEP 2: Setup accounts
|
|
// ═══════════════════════════════════════════════════════════════════════
|
|
println!("\n═══ STEP 2: Setup accounts ═══");
|
|
|
|
let alice = dev::alice();
|
|
let alice_account_id = AccountId32(alice.public_key().0);
|
|
|
|
println!("✓ Using Alice account");
|
|
println!(" Address: 5GrwvaEF5zXb26Fz9rcQpDWS57CtERHpNehXCPcNoHGKutQY");
|
|
|
|
// ═══════════════════════════════════════════════════════════════════════
|
|
// STEP 3: Query initial balances
|
|
// ═══════════════════════════════════════════════════════════════════════
|
|
println!("\n═══ STEP 3: Query initial balances ═══");
|
|
|
|
let relay_balance_before = query_relay_balance(&relay_api, &alice_account_id).await?;
|
|
println!(" Alice on Relay Chain:");
|
|
println!(
|
|
" Free balance: {} TYR ({:.4} HEZ)",
|
|
relay_balance_before,
|
|
relay_balance_before as f64 / PLANCKS_PER_HEZ as f64
|
|
);
|
|
|
|
let asset_hub_balance_before =
|
|
match query_asset_hub_balance(&asset_hub_api, &alice_account_id).await {
|
|
Ok(balance) => balance,
|
|
Err(_) => {
|
|
println!(" Alice on Asset Hub: (Account not found - will be created)");
|
|
0
|
|
},
|
|
};
|
|
if asset_hub_balance_before > 0 {
|
|
println!(" Alice on Asset Hub:");
|
|
println!(
|
|
" Free balance: {} TYR ({:.4} HEZ)",
|
|
asset_hub_balance_before,
|
|
asset_hub_balance_before as f64 / PLANCKS_PER_HEZ as f64
|
|
);
|
|
}
|
|
|
|
// ═══════════════════════════════════════════════════════════════════════
|
|
// STEP 4: Build and submit XCM teleport (for system teyrchains)
|
|
// ═══════════════════════════════════════════════════════════════════════
|
|
println!("\n═══ STEP 4: Execute XCM Teleport ═══");
|
|
|
|
// Transfer 0.1 HEZ (100 billion planck)
|
|
// Note: Alice has ~1 HEZ after previous transactions, so keep transfer small
|
|
let transfer_amount: u128 = PLANCKS_PER_HEZ / 10; // 0.1 HEZ
|
|
println!(" Transfer amount: {} TYR (0.1 HEZ)", transfer_amount);
|
|
|
|
// Build destination: Asset Hub (Teyrchain 1000) - Note: Junction::Teyrchain not Parachain
|
|
let dest = relay::runtime_types::xcm::VersionedLocation::V4(
|
|
relay::runtime_types::pezstaging_xcm::v4::location::Location {
|
|
parents: 0,
|
|
interior: relay::runtime_types::pezstaging_xcm::v4::junctions::Junctions::X1([
|
|
relay::runtime_types::pezstaging_xcm::v4::junction::Junction::Teyrchain(
|
|
ASSET_HUB_PARA_ID,
|
|
),
|
|
]),
|
|
},
|
|
);
|
|
|
|
// Build beneficiary: Alice's account on Asset Hub
|
|
let beneficiary = relay::runtime_types::xcm::VersionedLocation::V4(
|
|
relay::runtime_types::pezstaging_xcm::v4::location::Location {
|
|
parents: 0,
|
|
interior: relay::runtime_types::pezstaging_xcm::v4::junctions::Junctions::X1([
|
|
relay::runtime_types::pezstaging_xcm::v4::junction::Junction::AccountId32 {
|
|
network: None,
|
|
id: alice.public_key().0,
|
|
},
|
|
]),
|
|
},
|
|
);
|
|
|
|
// Build assets: Native token (HEZ)
|
|
let assets = relay::runtime_types::xcm::VersionedAssets::V4(
|
|
relay::runtime_types::pezstaging_xcm::v4::asset::Assets(vec![
|
|
relay::runtime_types::pezstaging_xcm::v4::asset::Asset {
|
|
id: relay::runtime_types::pezstaging_xcm::v4::asset::AssetId(
|
|
relay::runtime_types::pezstaging_xcm::v4::location::Location {
|
|
parents: 0,
|
|
interior:
|
|
relay::runtime_types::pezstaging_xcm::v4::junctions::Junctions::Here,
|
|
},
|
|
),
|
|
fun: relay::runtime_types::pezstaging_xcm::v4::asset::Fungibility::Fungible(
|
|
transfer_amount,
|
|
),
|
|
},
|
|
]),
|
|
);
|
|
|
|
// Weight limit: Unlimited
|
|
let weight_limit = relay::runtime_types::xcm::v3::WeightLimit::Unlimited;
|
|
|
|
// Fee asset item - use the native asset (index 0 in assets array, converted to VersionedAssetId)
|
|
let fee_asset = relay::runtime_types::xcm::VersionedAssetId::V4(
|
|
relay::runtime_types::pezstaging_xcm::v4::asset::AssetId(
|
|
relay::runtime_types::pezstaging_xcm::v4::location::Location {
|
|
parents: 0,
|
|
interior: relay::runtime_types::pezstaging_xcm::v4::junctions::Junctions::Here,
|
|
},
|
|
),
|
|
);
|
|
|
|
// Build the extrinsic - Use teleport for system teyrchains (Asset Hub)
|
|
// Note: System teyrchains like Asset Hub support teleportation from relay chain
|
|
let xcm_tx = relay::tx().xcm_pallet().limited_teleport_assets(
|
|
dest,
|
|
beneficiary,
|
|
assets,
|
|
fee_asset,
|
|
weight_limit,
|
|
);
|
|
|
|
println!("\n Submitting XCM transaction to Relay Chain...");
|
|
|
|
let tx_progress = relay_api.tx().sign_and_submit_then_watch_default(&xcm_tx, &alice).await?;
|
|
|
|
println!(" Transaction submitted, waiting for finalization...");
|
|
|
|
let events = tx_progress.wait_for_finalized_success().await?;
|
|
|
|
println!("✓ Transaction finalized on Relay Chain!");
|
|
|
|
// ═══════════════════════════════════════════════════════════════════════
|
|
// STEP 5: Check XCM events
|
|
// ═══════════════════════════════════════════════════════════════════════
|
|
println!("\n═══ STEP 5: Analyze XCM events ═══");
|
|
|
|
// Check for Attempted event
|
|
match events.find_first::<relay::xcm_pallet::events::Attempted>()? {
|
|
Some(event) => {
|
|
println!("✓ XCM Attempted event:");
|
|
println!(" Outcome: {:?}", event.outcome);
|
|
},
|
|
None => println!("⚠ No Attempted event found"),
|
|
}
|
|
|
|
// Check for Sent event
|
|
match events.find_first::<relay::xcm_pallet::events::Sent>()? {
|
|
Some(event) => {
|
|
println!("✓ XCM Sent event:");
|
|
println!(" Origin: {:?}", event.origin);
|
|
println!(" Destination: {:?}", event.destination);
|
|
},
|
|
None => println!("⚠ No Sent event found"),
|
|
}
|
|
|
|
// Check for FeesPaid event
|
|
match events.find_first::<relay::xcm_pallet::events::FeesPaid>()? {
|
|
Some(event) => {
|
|
println!("✓ XCM FeesPaid event:");
|
|
println!(" Fees: {:?}", event.fees);
|
|
},
|
|
None => println!(" (No FeesPaid event - fees may be zero)"),
|
|
}
|
|
|
|
// ═══════════════════════════════════════════════════════════════════════
|
|
// STEP 6: Wait for XCM to be processed on Asset Hub
|
|
// ═══════════════════════════════════════════════════════════════════════
|
|
println!("\n═══ STEP 6: Wait for Asset Hub processing ═══");
|
|
println!(" Waiting 12 seconds for XCM message to be delivered and processed...");
|
|
|
|
tokio::time::sleep(Duration::from_secs(12)).await;
|
|
|
|
// ═══════════════════════════════════════════════════════════════════════
|
|
// STEP 7: Query final balances
|
|
// ═══════════════════════════════════════════════════════════════════════
|
|
println!("\n═══ STEP 7: Query final balances ═══");
|
|
|
|
let relay_balance_after = query_relay_balance(&relay_api, &alice_account_id).await?;
|
|
let asset_hub_balance_after =
|
|
query_asset_hub_balance(&asset_hub_api, &alice_account_id).await.unwrap_or(0);
|
|
|
|
// ═══════════════════════════════════════════════════════════════════════
|
|
// STEP 8: Results and verification
|
|
// ═══════════════════════════════════════════════════════════════════════
|
|
println!("\n╔══════════════════════════════════════════════════════════════╗");
|
|
println!("║ TEST RESULTS ║");
|
|
println!("╠══════════════════════════════════════════════════════════════╣");
|
|
|
|
let relay_diff = relay_balance_before.saturating_sub(relay_balance_after);
|
|
let asset_hub_diff = asset_hub_balance_after.saturating_sub(asset_hub_balance_before);
|
|
|
|
println!("║ RELAY CHAIN (Alice): ║");
|
|
println!(
|
|
"║ Before: {:>20} TYR ({:>10.4} HEZ) ║",
|
|
relay_balance_before,
|
|
relay_balance_before as f64 / PLANCKS_PER_HEZ as f64
|
|
);
|
|
println!(
|
|
"║ After: {:>20} TYR ({:>10.4} HEZ) ║",
|
|
relay_balance_after,
|
|
relay_balance_after as f64 / PLANCKS_PER_HEZ as f64
|
|
);
|
|
println!(
|
|
"║ Spent: {:>20} TYR ({:>10.4} HEZ) ║",
|
|
relay_diff,
|
|
relay_diff as f64 / PLANCKS_PER_HEZ as f64
|
|
);
|
|
println!("║ ║");
|
|
println!("║ ASSET HUB (Alice): ║");
|
|
println!(
|
|
"║ Before: {:>20} TYR ({:>10.4} HEZ) ║",
|
|
asset_hub_balance_before,
|
|
asset_hub_balance_before as f64 / PLANCKS_PER_HEZ as f64
|
|
);
|
|
println!(
|
|
"║ After: {:>20} TYR ({:>10.4} HEZ) ║",
|
|
asset_hub_balance_after,
|
|
asset_hub_balance_after as f64 / PLANCKS_PER_HEZ as f64
|
|
);
|
|
println!(
|
|
"║ Received: {:>18} TYR ({:>10.4} HEZ) ║",
|
|
asset_hub_diff,
|
|
asset_hub_diff as f64 / PLANCKS_PER_HEZ as f64
|
|
);
|
|
println!("╠══════════════════════════════════════════════════════════════╣");
|
|
|
|
// Verification
|
|
if asset_hub_diff > 0 {
|
|
let fees = transfer_amount.saturating_sub(asset_hub_diff);
|
|
println!("║ ✓ SUCCESS: XCM transfer completed! ║");
|
|
println!("║ Transferred: {} TYR ║", transfer_amount);
|
|
println!("║ Received: {} TYR ║", asset_hub_diff);
|
|
println!("║ XCM Fees: {} TYR ║", fees);
|
|
println!("╚══════════════════════════════════════════════════════════════╝");
|
|
println!("\n✓ XCM RESERVE TRANSFER TEST PASSED!");
|
|
} else if relay_diff > 0 {
|
|
println!("║ ⚠ PARTIAL: Tokens deducted from Relay but not yet on AH ║");
|
|
println!("║ This may indicate XCM is still processing ║");
|
|
println!("║ or there was an error on the receiving side ║");
|
|
println!("╚══════════════════════════════════════════════════════════════╝");
|
|
println!("\n⚠ XCM TEST NEEDS INVESTIGATION");
|
|
} else {
|
|
println!("║ ✗ FAILED: No balance change detected ║");
|
|
println!("║ Check logs for XCM processing errors ║");
|
|
println!("╚══════════════════════════════════════════════════════════════╝");
|
|
println!("\n✗ XCM RESERVE TRANSFER TEST FAILED");
|
|
}
|
|
|
|
Ok(())
|
|
}
|