Fix WS/HTTP URI mismatch for live commands

rockbmb · rockbmb · commit d0e69c8f6576 · 2026-01-13T02:44:48.000Z
Live mode works with either ws(s):// or http(s):// in --uri. The endpoint is converted to HTTP for state download and to WS for block/header RPC. This is a temporary workaround until frame-remote-externalities restores proper WS transport support in a future release; see paritytech/polkadot-sdk#10258, paritytech/polkadot-sdk#10766, and paritytech/polkadot-sdk#10779 .
diff --git a/Cargo.lock b/Cargo.lock
diff --git a/Cargo.toml b/Cargo.toml
@@ -24,6 +24,7 @@ hex = { version = "0.4.3", default-features = false }
 itertools = { version = "~0.14" }
 log = { version = "~0.4.29" }
 parity-scale-codec = { version = "~3.7" }
+jsonrpsee = { version = "~0.24", features = ["http-client"] }
 regex = { version = "~1.12" }
 serde = { version = "~1.0" }
 serde_json = { version = "~1.0" }
@@ -69,8 +70,8 @@ sp-weights = { version = "33.2.0" }
 substrate-rpc-client = { version = "0.54.0" }
 
 polkadot-primitives = { version = "22.0.0" }
-cumulus-primitives-parachain-inherent = { version = "0.22.0" }
-cumulus-primitives-core = { version = "0.22.0" }
+cumulus-primitives-parachain-inherent = { version = "0.23.0" }
+cumulus-primitives-core = { version = "0.23.0" }
 cumulus-client-parachain-inherent = { version = "0.22.0" }
 
 # Local
diff --git a/cli/tests/create_snapshot.rs b/cli/tests/create_snapshot.rs
@@ -35,7 +35,8 @@ use tokio::process::Command;
 #[tokio::test]
 async fn create_snapshot_works() {
     let port = 45789;
-    let ws_url = format!("ws://localhost:{}", port);
+    let ws_uri = format!("ws://localhost:{}", port);
+    let http_uri = format!("http://localhost:{}", port);
 
     // Spawn a dev node.
     let _ = std::thread::spawn(move || {
@@ -66,29 +67,35 @@ async fn create_snapshot_works() {
 
     common::run_with_timeout(Duration::from_secs(60), async move {
         fn create_snapshot(
-            ws_url: &str,
+            uri: &str,
             snap_file: &PathBuf,
             at: sp_core::H256,
         ) -> tokio::process::Child {
             Command::new(cargo_bin!("try-runtime"))
                 .stdout(std::process::Stdio::piped())
                 .stderr(std::process::Stdio::piped())
                 .arg("--runtime=existing")
-                .args(["create-snapshot", format!("--uri={}", ws_url).as_str()])
+                .args(["create-snapshot", format!("--uri={}", uri).as_str()])
                 .arg(snap_file)
                 .args(["--at", format!("{:?}", at).as_str()])
                 .kill_on_drop(true)
                 .spawn()
                 .unwrap()
         }
         let block_number = 2;
-        let block_hash = common::block_hash(block_number, &ws_url).await.unwrap();
+        let block_hash = common::block_hash(block_number, &ws_uri).await.unwrap();
 
         // Try to create a snapshot.
-        let child = create_snapshot(&ws_url, &snap_file_path, block_hash);
+        let child = create_snapshot(&http_uri, &snap_file_path, block_hash);
         let out = child.wait_with_output().await.unwrap();
-
-        assert!(out.status.success());
+        assert!(
+            out.status.success(),
+            "try-runtime exited unsuccessfully: status={:?}, code={:?}\n\nstdout:\n{}\n\nstderr:\n{}",
+            out.status,
+            out.status.code(),
+            String::from_utf8_lossy(&out.stdout),
+            String::from_utf8_lossy(&out.stderr),
+        );
 
         let snapshot_is_on_disk = Path::new(&snap_file_path).exists();
         assert!(snapshot_is_on_disk, "Snapshot was not written to disk");
diff --git a/cli/tests/execute_block.rs b/cli/tests/execute_block.rs
@@ -50,26 +50,26 @@ async fn execute_block_works() {
 
     // Test passing --at
     common::run_with_timeout(Duration::from_secs(60), async move {
-        let ws_url = format!("ws://localhost:{}", port);
+        let ws_uri = format!("ws://localhost:{}", port);
 
-        fn execute_block(ws_url: &str, at: sp_core::H256) -> tokio::process::Child {
+        fn execute_block(uri: &str, at: sp_core::H256) -> tokio::process::Child {
             Command::new(cargo_bin!("try-runtime"))
                 .stdout(std::process::Stdio::piped())
                 .stderr(std::process::Stdio::piped())
                 .arg("--runtime=existing")
                 .args(["execute-block"])
-                .args(["live", format!("--uri={}", ws_url).as_str()])
+                .args(["live", format!("--uri={}", uri).as_str()])
                 .args(["--at", format!("{:?}", at).as_str()])
                 .kill_on_drop(true)
                 .spawn()
                 .unwrap()
         }
 
         let block_number = 3;
-        let block_hash = common::block_hash(block_number, &ws_url).await.unwrap();
+        let block_hash = common::block_hash(block_number, &ws_uri).await.unwrap();
 
         // Try to execute the block.
-        let mut block_execution = execute_block(&ws_url, block_hash);
+        let mut block_execution = execute_block(&ws_uri, block_hash);
 
         // The execute-block command is actually executing the next block.
         let expected_output = format!(r#".*Block #{} successfully executed"#, block_number);
@@ -92,7 +92,7 @@ async fn execute_block_works() {
 
     // Test not passing --at
     common::run_with_timeout(Duration::from_secs(60), async move {
-        let ws_url = format!("ws://localhost:{}", port);
+        let ws_uri = format!("ws://localhost:{}", port);
 
         fn execute_block(ws_url: &str) -> tokio::process::Child {
             Command::new(cargo_bin!("try-runtime"))
@@ -107,7 +107,7 @@ async fn execute_block_works() {
         }
 
         // Try to execute the block.
-        let mut block_execution = execute_block(&ws_url);
+        let mut block_execution = execute_block(&ws_uri);
         let expected_output = r".*Block #(\d+) successfully executed";
         let re = Regex::new(expected_output).unwrap();
         let matched =
diff --git a/cli/tests/follow_chain.rs b/cli/tests/follow_chain.rs
@@ -27,7 +27,8 @@ use tokio::process::Command;
 #[tokio::test]
 async fn follow_chain_works() {
     let port = 45789;
-    let ws_url = format!("ws://localhost:{}", port);
+    let ws_uri = format!("ws://localhost:{}", port);
+    let http_uri = format!("http://localhost:{}", port);
 
     // Spawn a dev node.
     let _ = std::thread::spawn(move || {
@@ -49,19 +50,19 @@ async fn follow_chain_works() {
     std::thread::sleep(Duration::from_secs(180));
 
     common::run_with_timeout(Duration::from_secs(60), async move {
-        fn start_follow(ws_url: &str) -> tokio::process::Child {
+        fn start_follow(uri: &str) -> tokio::process::Child {
             Command::new(cargo_bin!("try-runtime"))
                 .stdout(std::process::Stdio::piped())
                 .stderr(std::process::Stdio::piped())
                 .arg("--runtime=existing")
-                .args(["follow-chain", format!("--uri={}", ws_url).as_str()])
+                .args(["follow-chain", format!("--uri={}", uri).as_str()])
                 .kill_on_drop(true)
                 .spawn()
                 .unwrap()
         }
 
         // Kick off the follow-chain process and wait for it to process at least 3 blocks.
-        let mut follow = start_follow(&ws_url);
+        let mut follow = start_follow(&http_uri);
         let re = Regex::new(r".*executed block ([3-9]|[1-9]\d+).*").unwrap();
         let matched =
             common::wait_for_stream_pattern_match(follow.stderr.take().unwrap(), re).await;
diff --git a/core/src/commands/create_snapshot.rs b/core/src/commands/create_snapshot.rs
@@ -23,6 +23,7 @@ use substrate_rpc_client::{ws_client, StateApi};
 
 use crate::{
     common::{
+        parse,
         shared_parameters,
         state::{build_executor, LiveState, RuntimeChecks, State},
     },
@@ -62,10 +63,12 @@ where
     let path = match snapshot_path {
         Some(path) => path,
         None => {
-            let rpc = ws_client(&command.from.uri).await.unwrap();
+            let rpc = ws_client(&parse::to_ws_uri(&command.from.uri))
+                .await
+                .map_err(|e| format!("failed to build ws client: {e:?}"))?;
             let remote_spec = StateApi::<Block::Hash>::runtime_version(&rpc, None)
                 .await
-                .unwrap();
+                .map_err(|e| format!("failed to fetch runtime version: {e:?}"))?;
             let path_str = format!(
                 "{}-{}@{}.snap",
                 remote_spec.spec_name.to_lowercase(),
diff --git a/core/src/commands/execute_block.rs b/core/src/commands/execute_block.rs
@@ -96,7 +96,7 @@ where
 {
     let executor = build_executor::<HostFns>(&shared);
     let block_ws_uri = command.block_ws_uri();
-    let rpc = ws_client(&block_ws_uri).await?;
+    let rpc = ws_client(&crate::common::parse::to_ws_uri(&block_ws_uri)).await?;
 
     let live_state = match command.state {
         State::Live(live_state) => {
diff --git a/core/src/commands/follow_chain.rs b/core/src/commands/follow_chain.rs
@@ -73,7 +73,7 @@ pub struct Command {
 async fn start_subscribing<Header: DeserializeOwned + Serialize + Send + Sync + 'static>(
     url: &str,
 ) -> sc_cli::Result<(WsClient, Subscription<Header>)> {
-    let client = ws_client(url)
+    let client = ws_client(&parse::to_ws_uri(url))
         .await
         .map_err(|e| sc_cli::Error::Application(e.into()))?;
 
diff --git a/core/src/commands/offchain_worker.rs b/core/src/commands/offchain_worker.rs
@@ -76,7 +76,7 @@ where
 {
     let executor = build_executor(&shared);
     let block_ws_uri = command.header_ws_uri();
-    let rpc = ws_client(&block_ws_uri).await?;
+    let rpc = ws_client(&parse::to_ws_uri(&block_ws_uri)).await?;
 
     let live_state = match command.state {
         State::Live(live_state) => live_state,
diff --git a/core/src/common/empty_block/production.rs b/core/src/common/empty_block/production.rs
@@ -1,5 +1,6 @@
 use std::{ops::DerefMut, str::FromStr, sync::Arc};
 
+use array_bytes::Hexify;
 use parity_scale_codec::{Decode, Encode};
 use sc_cli::Result;
 use sc_executor::{HostFunctions, WasmExecutor};
@@ -66,7 +67,7 @@ where
 
     log::info!(
         "Produced a new block ({})",
-        array_bytes::bytes2hex("0x", next_block.header().hash())
+        next_block.header().hash().as_bytes().hexify_prefixed()
     );
 
     let mut ext_guard = ext_mutex.lock().await;
diff --git a/core/src/common/parse.rs b/core/src/common/parse.rs
@@ -35,14 +35,44 @@ pub(crate) fn hash(block_hash: &str) -> Result<String, String> {
 }
 
 pub(crate) fn url(s: &str) -> Result<String, &'static str> {
-    if s.starts_with("ws://") || s.starts_with("wss://") {
+    if s.starts_with("ws://")
+        || s.starts_with("wss://")
+        || s.starts_with("http://")
+        || s.starts_with("https://")
+    {
         // could use Url crate as well, but lets keep it simple for now.
         Ok(s.to_string())
     } else {
-        Err("not a valid WS(S) url: must start with 'ws://' or 'wss://'")
+        Err("not a valid URL: must start with 'ws://', 'wss://', 'http://' or 'https://'")
     }
 }
 
+/// Convert an input URI into a WS URI suitable for `ws_client`.
+///
+/// If the input is HTTP(S), it will be converted to WS(S). Otherwise returned unchanged.
+pub(crate) fn to_ws_uri(uri: &str) -> String {
+    if let Some(rest) = uri.strip_prefix("http://") {
+        return format!("ws://{rest}");
+    }
+    if let Some(rest) = uri.strip_prefix("https://") {
+        return format!("wss://{rest}");
+    }
+    uri.to_string()
+}
+
+/// Convert an input URI into an HTTP URI suitable for `frame_remote_externalities` online transport.
+///
+/// If the input is WS(S), it will be converted to HTTP(S). Otherwise returned unchanged.
+pub(crate) fn to_http_uri(uri: &str) -> String {
+    if let Some(rest) = uri.strip_prefix("ws://") {
+        return format!("http://{rest}");
+    }
+    if let Some(rest) = uri.strip_prefix("wss://") {
+        return format!("https://{rest}");
+    }
+    uri.to_string()
+}
+
 pub(crate) fn state_version(s: &str) -> Result<StateVersion, &'static str> {
     s.parse::<u8>()
         .map_err(|_| ())
diff --git a/core/src/common/state.rs b/core/src/common/state.rs
@@ -113,7 +113,7 @@ impl LiveState {
 
         // Get the block number requested by the user, or the current block number if they
         // didn't specify one.
-        let rpc = ws_client(&self.uri).await?;
+        let rpc = ws_client(&parse::to_ws_uri(&self.uri)).await?;
         let previous_hash = ChainApi::<(), Block::Hash, Block::Header, ()>::header(&rpc, at)
             .await
             .map_err(rpc_err_handler)
@@ -205,7 +205,7 @@ impl State {
                     .collect::<Result<Vec<_>, _>>()?;
                 Builder::<Block>::new().mode(Mode::Online(OnlineConfig {
                     at,
-                    transport: uri.to_owned().into(),
+                    transport: parse::to_http_uri(uri).into(),
                     state_snapshot,
                     pallets: pallet.clone(),
                     child_trie: *child_tree,

Original file line number	Diff line number	Diff line change
`@@ -96,7 +96,7 @@ where`
`96`	`96`	`{`
`97`	`97`	`let executor = build_executor::<HostFns>(&shared);`
`98`	`98`	`let block_ws_uri = command.block_ws_uri();`
`99`		`- let rpc = ws_client(&block_ws_uri).await?;`
	`99`	`+ let rpc = ws_client(&crate::common::parse::to_ws_uri(&block_ws_uri)).await?;`
`100`	`100`
`101`	`101`	`let live_state = match command.state {`
`102`	`102`	`State::Live(live_state) => {`
Original file line number	Diff line number	Diff line change
`@@ -76,7 +76,7 @@ where`
`76`	`76`	`{`
`77`	`77`	`let executor = build_executor(&shared);`
`78`	`78`	`let block_ws_uri = command.header_ws_uri();`
`79`		`- let rpc = ws_client(&block_ws_uri).await?;`
	`79`	`+ let rpc = ws_client(&parse::to_ws_uri(&block_ws_uri)).await?;`
`80`	`80`
`81`	`81`	`let live_state = match command.state {`
`82`	`82`	`State::Live(live_state) => live_state,`