Update ureq

Author: shesek

Cargo.lock

@@ -81,7 +81,7 @@ electrs_macros = { path = "electrs_macros", default-features = false }
 bitcoind = { version = "0.36", features = ["25_0"] }
 elementsd = { version = "0.11", features = ["22_1_1"] }
 electrumd = { version = "0.1.0", features = ["4_5_4"] }
-ureq = { version = "2.9", default-features = false, features = ["json"] }
+ureq = { version = "3.1", default-features = false, features = ["json"] }
 tempfile = "3.10"
 criterion = { version = "0.4", features = ["html_reports"] }
 bitcoin-test-data = { version = "*" }

Cargo.toml

@@ -3,7 +3,6 @@ use bitcoin::hex::FromHex;
 use bitcoind::bitcoincore_rpc::RpcApi;
 use serde_json::Value;
 use std::collections::HashSet;
-use std::io::Read;
 use std::net;
 
 #[cfg(not(feature = "liquid"))]
@@ -15,16 +14,19 @@ pub mod common;
 
 use common::Result;
 
-fn get(rest_addr: net::SocketAddr, path: &str) -> std::result::Result<ureq::Response, ureq::Error> {
+fn get(
+    rest_addr: net::SocketAddr,
+    path: &str,
+) -> std::result::Result<ureq::http::Response<ureq::Body>, ureq::Error> {
     ureq::get(&format!("http://{}{}", rest_addr, path)).call()
 }
 
 fn get_json(rest_addr: net::SocketAddr, path: &str) -> Result<Value> {
-    Ok(get(rest_addr, path)?.into_json::<Value>()?)
+    Ok(get(rest_addr, path)?.into_body().read_json()?)
 }
 
 fn get_plain(rest_addr: net::SocketAddr, path: &str) -> Result<String> {
-    Ok(get(rest_addr, path)?.into_string()?)
+    Ok(get(rest_addr, path)?.into_body().read_to_string()?)
 }
 
 #[test]
@@ -320,9 +322,9 @@ fn test_rest_block() -> Result<()> {
     }
 
     // Test GET /block/:hash/raw
-    let mut res = get(rest_addr, &format!("/block/{}/raw", blockhash))?.into_reader();
-    let mut rest_rawblock = Vec::new();
-    res.read_to_end(&mut rest_rawblock).unwrap();
+    let rest_rawblock = get(rest_addr, &format!("/block/{}/raw", blockhash))?
+        .into_body()
+        .read_to_vec()?;
     let node_hexblock = // uses low-level call() to support Elements
         tester.call::<String>("getblock", &[blockhash.to_string().into(), 0.into()])?;
     assert_eq!(rest_rawblock, Vec::from_hex(&node_hexblock).unwrap());
@@ -397,13 +399,19 @@ fn test_rest_broadcast_tx() -> Result<()> {
     let txid = tester.send(&addr1, "9.9 BTC".parse().unwrap())?;
     let tx_hex = get_plain(rest_addr, &format!("/tx/{}/hex", txid))?;
     // Re-send the tx created by send(). It'll be accepted again since its still in the mempool.
-    let broadcast1_resp = ureq::post(&format!("http://{}/tx", rest_addr)).send_string(&tx_hex)?;
+    let broadcast1_resp = ureq::post(&format!("http://{}/tx", rest_addr)).send(&tx_hex)?;
     assert_eq!(broadcast1_resp.status(), 200);
-    assert_eq!(broadcast1_resp.into_string()?, txid.to_string());
+    assert_eq!(
+        broadcast1_resp.into_body().read_to_string()?,
+        txid.to_string()
+    );
     // Mine the tx then submit it again. Should now fail.
     tester.mine()?;
-    let broadcast2_res = ureq::post(&format!("http://{}/tx", rest_addr)).send_string(&tx_hex);
-    let broadcast2_resp = broadcast2_res.unwrap_err().into_response().unwrap();
+    let broadcast2_resp = ureq::post(&format!("http://{}/tx", rest_addr))
+        .config()
+        .http_status_as_error(false)
+        .build()
+        .send(&tx_hex)?;
     assert_eq!(broadcast2_resp.status(), 400);
 
     rest_handle.stop();
@@ -416,24 +424,27 @@ fn test_rest_package_validation() -> Result<()> {
 
     // Test POST /txs/package - simple validation test
     // Test with invalid JSON first to verify the endpoint exists
-    let invalid_package_result = ureq::post(&format!("http://{}/txs/package", rest_addr))
-        .set("Content-Type", "application/json")
-        .send_string("invalid json");
-    let invalid_package_resp = invalid_package_result.unwrap_err().into_response().unwrap();
-    let status = invalid_package_resp.status();
+    let invalid_package_resp = ureq::post(&format!("http://{}/txs/package", rest_addr))
+        .header("Content-Type", "application/json")
+        .config()
+        .http_status_as_error(false)
+        .build()
+        .send("invalid json")?;
     // Should be 400 for bad JSON, not 404 for missing endpoint
     assert_eq!(
-        status, 400,
+        invalid_package_resp.status(),
+        400,
         "Endpoint should exist and return 400 for invalid JSON"
     );
 
     // Now test with valid but empty package, should fail
-    let empty_package_result = ureq::post(&format!("http://{}/txs/package", rest_addr))
-        .set("Content-Type", "application/json")
-        .send_string("[]");
-    let empty_package_resp = empty_package_result.unwrap_err().into_response().unwrap();
-    let status = empty_package_resp.status();
-    assert_eq!(status, 400);
+    let empty_package_resp = ureq::post(&format!("http://{}/txs/package", rest_addr))
+        .header("Content-Type", "application/json")
+        .config()
+        .http_status_as_error(false)
+        .build()
+        .send("[]")?;
+    assert_eq!(empty_package_resp.status(), 400);
 
     rest_handle.stop();
     Ok(())
@@ -1145,15 +1156,11 @@ fn test_rest_submit_package() -> Result<()> {
     }
 
     // Now submit this transaction package via the package endpoint
-    let package_json =
-        serde_json::json!([tx1_signed_hex.clone(), tx2_signed_hex.clone()]).to_string();
-    let package_result = ureq::post(&format!("http://{}/txs/package", rest_addr))
-        .set("Content-Type", "application/json")
-        .send_string(&package_json);
+    let package_resp = ureq::post(&format!("http://{}/txs/package", rest_addr))
+        .send_json([tx1_signed_hex, tx2_signed_hex])?;
 
-    let package_resp = package_result.unwrap();
     assert_eq!(package_resp.status(), 200);
-    let package_result = package_resp.into_json::<Value>()?;
+    let package_result = package_resp.into_body().read_json::<Value>()?;
 
     // Verify the response structure
     assert!(package_result["tx-results"].is_object());